语源科技BlogJava-peacess

平台项目中的平衡

中东 — Wed, 04 Sep 2013 13:25:00 GMT

项目做多了，总想着把一些共同的东西抽取出来以后使用。。。。。
突然有一天有一个机会在项目中把一些我认为有用的东西抽取出来放到那里，。。。。。
突然有一天发现原来自己抽取出来的东西从来就没有使用过。。。。。
每当遇到问题要解决时，总还是网上到处找，突然找到一个文章写的很好。。。。。。最后发现这个文章是自己写的
多了时间久了，就会忘记。

项目开始：
在项目开始初期总对项目有一大堆的想法，要把这个做成公用，要把那个独立出来，。。。。是否是要做一个通用的平台出来，以后开发就省事了。。。。。。

项目进行中：
客户的要求在变化。。。。
团队在变化。。。。
代码量也上来了。。。。
这时项目的设计变化在不断的进行着，经常同样一件事情会反复做多次。。。。
客户的压力、团队人员的情绪等也产生了，这时项目的时间也不多了。。。。。

项目项目结束中：
客户在一天天的要求进度。。。。。
团队人员已开始做下一个项目的准备，在想下一个项目一定做好。。。。。
客户团队都处在痛苦中。。。。。
项目开始进入大量的加班中。。。。。

项目结束了。

总结：要在项目开始的时候设一个宏大的目标，做那多的抽取吗？如果不做抽取，项目会不会做的质量高一点，加班加的少一点。

。。。。。不管理怎么样，第一要解决问题，不然其它什么都等于零。

中东 2013-09-04 21:25 发表评论

ant中的文件复制问题

中东 — Sat, 11 Aug 2007 08:02:00 GMT

ant的文件复制常会出问题：
    ant没有任何提示，也没有把文件复制到指定的地方（源文件已经改变）。这样经常会使用程序编译或运行产生奇怪的错误，因为它使用了旧的没有更新的文件
解决方法
    在复制文件之前，先把文件删除（如果文件不能被删除，ant会有提示）
    在jar之前也要做相同的事情

中东 2007-08-11 16:02 发表评论

gwt项目开发的经验集----会一直增加

中东 — Mon, 06 Aug 2007 14:41:00 GMT

摘要: 13，用gwt在web中实现上下文菜单（右键菜单、弹出菜单） 2007年8月3日
12，gwt中使用float样式实现完成 2007年7月28日
11，11，文件下载（downloat，通过表单方式）完成 2007年8月6日
10，阻止事件传到父对象 2007年7月31日
9，文件上传客户端（隐藏表单） 2007年7月29日
8，不换行：表格字符、多种widget的组合计划中
7，css的（边框）margin、border、padding、width、height与dom对象的属clientWidth、offsetWidth、offsetHeight等的关系及gwt的获取与设置> 完成 2007年5月9日
6，学习资源完成 2006年12月21日
5，给gwt的ui组件增加事件完成 2006年12月17日
4，按钮的鼠标进出样式完成 2006年12月14日
3，元素宽度计算完成
2，对话框居中完成
< 阅读全文

中东 2007-08-06 22:41 发表评论

gwt在eclipse、tomcat中单步调试客户与服务的完整实例---（升级为gwt1.4 进行中）

中东 — Thu, 26 Jul 2007 12:44:00 GMT

使用tomcat进行浏览，而不使用gwt自带的，这样可以取得tomcat的上下文信息，并可以单步客户端

完整的源代码（为了方便编译后的文件也保留了）：Wylpeace-tomcat

环境的建立
1，下载eclipse3.3 :http://download.eclipse.org/eclipse/downloads/index.php
2，下载tomcat6.0 : http://tomcat.apache.org/download-60.cgi
3，下载Tomcat Plugin：http://www.sysdeo.com/eclipse/tomcatplugin
4，安装（怎么安装就自己去google吧）

正式开工
建一个用eclipse开发的gwt项目（如果不想建立，可以下载源代码）
    gwt的命令行方式:http://code.google.com/webtoolkit/gettingstarted.html

在eclipse中配置tomcat的运行环境

    首先把插件配置好
    window--》preference--》tomcat：配置“tomcat home”与“tomcat vesion” --》advanced ：配置“tomcat base”（与“tomcat home”相同） --》jvm setting ：选择“jre”，注意一定是jdk下的jre，不然不能调试服务端代码

    然后呢（配置的内容比较多，没有办法）
    1，在项目下建，如下目录wylpeace.samples.select.WylpeaceSelect/WEB-INF/classes、wylpeace.samples.select.WylpeaceSelect/WEB-INF/lib
    2，在“WEB-INF”下加入文件“web.xml”内容如源代码
    3，把文件gwt-user.jar、gwt-dev-windows.jar、gwt-ll.dll、swt-win32-3235.dll、ojdbc14.jar放入lib目录。
    4，增加库引用“gwt-user.jar、gwt-dev-windows.jar、ojdbc14.jar ”
    5，修改class文件的输出路径，如下图

配置gwt的hosted

    1，右键项目“Wylpeace”--》debug as--》debug如下图所示

    注意图中的选中部分“-noserver -port 8080”(用这种方式可以改变gwt的默认端口8888)，
    还是在这个图中“classpath”标签进行修改,参见：http://www.blogjava.net/peacess/archive/2007/07/24/49447.html

配置tomcat插件

所有配置都完成了，我们可以开始单步调试了
首先重起tomcat（在eclipse中），在调试运行“wylpeace”
这时会提示找不到网页，修改url为：http://localhost:8080/wylpeace.samples.select.WylpeaceSelect/WylpeaceSelect.html
好了整个过程结束，如果有什么问题请联系
    mail：peacess@163.com
    qq：64407724
你也可以参考：http://jroller.com/page/masini?entry=deploy_and_debug_google_web
你也可以参考：http://groups.google.com/group/Google-Web-Toolkit/browse_thread/thread/338c4b765d7dfc39/c9382d0e65266248?q=tomcat&rnum=3#c9382d0e65266248

中东 2007-07-26 20:44 发表评论

gwt 1.4学习--数据库记录显示实现（二.1）(把源来的内容升级为gwt1.4)

中东 — Tue, 24 Jul 2007 14:42:00 GMT

实现的功能
   在gwt开发中实现，与数据库（oracle）的连接(jdbc)，并显示数据记录集，说白了就是在ajax的gwt架构下与数据库交互。
相关工具
gwt1.4，eclipse3.3
首先说明一下要原理
分为两部分：客户端部分与服务端部分
如果对gwt的远程调用不怎么清楚，请参见：http://code.google.com/webtoolkit/documentation/com.google.gwt.doc.DeveloperGuide.RemoteProcedureCalls.html

客户端部分
   由于客户端只支持jdk1.4的包util与lang（没有jdbc），所以只能自己写一个类存放记录集，如下
public class PeaceResultSet {
    private String[] cols;
    /**
    * @gwt.typeArgs
    */
    private List rows;
    public String[] getCols() {
        return cols;
    }
    public void setCols(String[] cols) {
        this.cols = cols;
    }
    public List getRows() {
        return rows;
    }
    public void setRows(List rows) {
        this.rows = rows;
    }
}
    对此类作一个简单的说明。cols是存放列名的，rows是存放记录行的，请注意在它前面的那一个注释（/**
    * @gwt.typeArgs
    */），一定不能少的，因为，最终这个java代码会被转换成javascript，这里告诉转换的类型的
有了记录集，我们就可以用FlexTable来把我们的记录集显示出来了,如下
public class PeaceTable extends Composite{

    private FlexTable table = new FlexTable();
    public FlexTable getTable() {
        return table;
    }
    public PeaceTable() {
        this.initWidget(table);
    }
    public void showResultSet(PeaceResultSet re)
    {
        this.table.clear();
        if(re != null && re.getRows()!= null && re.getRows().size()>0)
        {
            String[] cols = re.getCols();
            List rows = re.getRows();

            for(int j = cols.length-1; j >= 0; j--)
            {
                table.setText(0,j,cols[j]);
            }

            for(int i = 0; i < rows.size(); i++)
            {
                cols = (String[])rows.get(i);
                for(int j = cols.length-1; j >= 0; j--)
                {
                    table.setText(i+1,j,cols[j]);
                }
            }
        }
        else
        {
            table.setText(0,0,"no data");
        }
    }
    public void callServer(String sql) {
        PeaceSelectResultSetAsync.Util.getInstance().select(sql, new AsyncCallback() {
            public void onFailure(Throwable caught) {
            }
            public void onSuccess(Object result) {
                showResultSet((PeaceResultSet) result);
            }
          });
    }
服务端部分
这一部分是完全的java，可以用java可以使用的全部库（当然自己写的也可以）
我这里用的是jdbc来连接数据库（只是最简单的，因为这里不是说明数据怎么操作的），代码如下
public class PeaceSelectResultSetImpl extends RemoteServiceServlet implements
        PeaceSelectResultSet {

    private static final long serialVersionUID = 1L;

    public PeaceResultSet select(String sql) {
        Connection conn = null;
        Statement stmt = null;
        ResultSet se = null;
        try {
            Class.forName("oracle.jdbc.driver.OracleDriver").newInstance();
            String url = "jdbc:oracle:thin:@192.168.1.11:1521:XXXX"; // orclΪ��ݿ��SID
            String user = "uuser";
            String password = "pwd";
            conn = DriverManager.getConnection(url, user, password);
            stmt = conn.createStatement();
            se = stmt.executeQuery(sql);
            ResultSetMetaData rsmd = se.getMetaData();

            String[] cols = new String[rsmd.getColumnCount()];
            List rows = new ArrayList();
            for (int i = cols.length; i > 0; i--) {
                cols[i - 1] = rsmd.getColumnName(i);
            }
            while (se.next()) {
                String[] row = new String[cols.length];
                rows.add(row);
                for (int i = cols.length - 1; i >= 0; i--) {
                    row[i] = se.getString(cols[i]);
                }
            }
            PeaceResultSet kfse = new PeaceResultSet();
            kfse.setCols(cols);
            kfse.setRows(rows);
            return kfse;
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if (se != null)
                try {
                    se.close();
                } catch (SQLException e1) {
                    e1.printStackTrace();
                }
            if (stmt != null)
                try {
                    stmt.close();
                } catch (SQLException e1) {
                    e1.printStackTrace();
                }
            if (conn != null)
                try {
                    conn.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
        }
        return null;
    }
}
在下一部分中，我将说明一些注意事项，以及给出完整的源代码！！

中东 2007-07-24 22:42 发表评论

gwt 1.4 学习--数据库记录显示实现（二.2）(把源来的内容升级为gwt1.4)

中东 — Tue, 24 Jul 2007 14:42:00 GMT

接着上一次的内容
注意事项：
    在客户端部分，只能使用jdk的一部分
    把服务端的程序写完后，记得在文件“WylpeaceSelect.gwt.xml”中进行配置，如下代码

          。。。。。。。

          。。。。。。。。

    在eclipse中调试时，会提示找不数据库相的类，要记住做如下操作
       。。。“debug”----》选中“WylpeaceSelect”----》选中“classpath”，单击右下的“restore default entries”，再单击“addvaced”增加源代码目录
如图：

完整个代码（eclipse）：WylpeaceSelect
注意：
     下载代码后修改WylpeaceSelect.launch中的gwt包的路径
      注意加入你的数据库包（oracle的jdbc）

中东 2007-07-24 22:42 发表评论

hibernate 多对多关系在mysql、oracle中的不同

中东 — Mon, 11 Jun 2007 15:19:00 GMT

用户（User）与角色（Role）多对多关系（UserRole）
下面是表的代码（配置为annotation）
User：

package sub;
import java.io.Serializable;
import java.util.Set;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.JoinTable;
import javax.persistence.ManyToMany;
@Entity
public class User implements Serializable
{
    /**
     *
     */
    private static final long serialVersionUID = 1L;
    private Long id;
    private Set roles;
    @Id
    @GeneratedValue
    public Long getId()
    {
        return id;
    }
    public void setId(Long id)
    {
        this.id = id;
    }
    @ManyToMany
    @JoinTable(name="UserRole",joinColumns={@JoinColumn(name="user_ID")},inverseJoinColumns={@JoinColumn(name="role_ID")})
    public Set getRoles()
    {
        return roles;
    }
    public void setRoles(Set roles)
    {
        this.roles = roles;
    }
}

Role：

package sub;
import java.io.Serializable;
import java.util.Set;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.JoinTable;
import javax.persistence.ManyToMany;
@Entity
public class Role implements Serializable
{
    /**
     *
     */
    private static final long serialVersionUID = 1L;
    private Long id;
    private Set users;
    @Id
    @GeneratedValue
    public Long getId()
    {
        return id;
    }
    public void setId(Long id)
    {
        this.id = id;
    }
    @ManyToMany
    @JoinTable(name="UserRole",joinColumns={@JoinColumn(name="role_ID")},inverseJoinColumns={@JoinColumn(name="user_ID")})
    public Set getUsers()
    {
        return users;
    }
    public void setUsers(Set users)
    {
        this.users = users;
    }
}

UserRoleId：

package sub;
import java.io.Serializable;
import javax.persistence.Embeddable;
@Embeddable
public class UserRoleId implements Serializable
{
    /**
     *
     */
    private static final long serialVersionUID = 1L;
    private Long userId;
    private Long roleId;
    public UserRoleId(Long userId, Long roleId)
    {
        this.userId = userId;
        this.roleId = roleId;
    }
    public UserRoleId()
    {
        this(null,null);
    }
    @Override
    public boolean equals(Object obj)
    {
        if(obj == this)return true;
        if(obj instanceof UserRoleId)
        {
            final UserRoleId other = (UserRoleId) obj;
            Long userT = getUserId();
            Long userOther = other.getUserId();
            Long roleT = getRoleId();
            Long roleOther = other.getRoleId();

            return ((userT == userOther) || (userT != null &&
                    userOther != null && userT.equals(userOther))) &&
                    ((roleT == roleOther) || (roleT != null &&
                            roleOther != null && roleT.equals(
                                    roleOther)));
        }
        return false;
    }
    @Override
    public int hashCode()
    {
        int re = 17;
        re += (userId == null?0:userId.hashCode());
        re += (roleId == null?0:roleId.hashCode());
        return 37*re;
    }
    public Long getUserId()
    {
        return userId;
    }
    public void setUserId(Long userId)
    {
        this.userId = userId;
    }
    public Long getRoleId()
    {
        return roleId;
    }
    public void setRoleId(Long roleId)
    {
        this.roleId = roleId;
    }
}

UserRole：

package sub;
import java.io.Serializable;
import javax.persistence.AttributeOverride;
import javax.persistence.AttributeOverrides;
import javax.persistence.Column;
import javax.persistence.EmbeddedId;
import javax.persistence.Entity;
import javax.persistence.FetchType;
import javax.persistence.JoinColumn;
import javax.persistence.ManyToOne;
@Entity
public class UserRole implements Serializable
{
    /**
     *
     */
    private static final long serialVersionUID = 1L;
    private UserRoleId id;
    private Role role;
    private User user;
    @EmbeddedId
    @AttributeOverrides( {
            @AttributeOverride(name = "userId", column = @Column(name = "user_ID", unique = false, nullable = false, insertable = true, updatable = true)),
            @AttributeOverride(name = "roleId", column = @Column(name = "role_ID", unique = false, nullable = false, insertable = true, updatable = true)) })
    public UserRoleId getId()
    {
        return id;
    }
    @ManyToOne(cascade = {})
    @JoinColumn(name = "role_ID", unique = false, nullable = false, insertable = false, updatable = false)
    public Role getRole()
    {
        return role;
    }
    @ManyToOne(cascade = {}, fetch = FetchType.EAGER)
    @JoinColumn(name = "user_ID", unique = false, nullable = false, insertable = false, updatable = false)
    public User getUser()
    {
        return user;
    }
    public void setId(UserRoleId id)
    {
        this.id = id;
    }
    public void setRole(Role role)
    {
        this.role = role;
    }
    public void setUser(User user)
    {
        this.user = user;
    }
}

在mysql数据库中，保存UserRole时出错。而完全相同的代码在oracle数据中正确。
操作如下：

        User user;
        Role role;
        //经过多步操作以后，user与role都保存到数据库，与之相关联的session已关闭
        Session s = null;//取得s的代码没有写出来
        s.beginTransaction();
        UserRole userRole = new UserRole();
        userRole.setId(new UserRoleId(user.getId(),role.getId()));
        userRole.setUser(user);
        userRole.setRole(role);
        s.persist(userRole);
        s.getTransaction().commit();
//一提交就出错，提示user没有保存，但是奇怪的是为什么在oracle中完全正确。
//最后在mysql中作如下的修改可以正确保存
//把 userRole.setUser(user)与userRole.setRole(role)删除

有那位知道是什么问题，请告之

中东 2007-06-11 23:19 发表评论

失去了什么----提高项目进度

中东 — Mon, 20 Nov 2006 14:03:00 GMT

当项目进度被一再加快时，到最后项目还是做出来了，到底从中失去了什么？？

做开发的失去了什么？做管理的失去了什么？做客户的失去了什么？产品呢，它又失去什么？

可能都失去了！因为后继的工作量比开发的还要大的多，如果项目经理不下大力气加班的话，整个项目可能

都没有办法维护。

可能都没有失去，因为没有完全相同的两个项目来进行比较，谁也没有办法量化，到底失去了什么？

到底失去了什么？到底失去了什么？？

中东 2006-11-20 22:03 发表评论

清空数据库数据（表）的一个解决方案

中东 — Thu, 09 Nov 2006 09:18:00 GMT

在做数据库开发中，经常都要清空（delete）数据或删除（drop）所有的表。然而，外键的存在，给这个工作带来了很大的不便。这里用jdbc写一个通用的类，产生出清空或删除表的顺序。
以下代码在mysql与oracle下面运行正常

(在同行的建议下作了一些改进，又增加了一些功能，见类注释)
代码：

package createData.tryDemo;

import java.sql.Connection;
import java.sql.DatabaseMetaData;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

/**
* 外键工具
* 1，返回清空（删除）数据库表的先后顺序
* 2，找出数据库中的外键环
* 3，找出数据库中的对同一个表的重复外键关联
*
* 注：外键环（不知道在数据库中，对此情况有没有别的命名）
* 情况1，外键表是自己（自外键环、小外键环、单外键环）
* 情况2，aTable的外键表是bTable，而bTable的外键表又是aTable（双外键环）
* 情况3，就是多个表之间形成的外键环（多外键环）
* @author wpeace
*
*/
public class ExportedKeysTools
{
    public static void main(String[] args)
    {
        //得到一个数据库的连接，这里就不细说了
        Connection connection = null;

        List tables = ExportedKeysTools.getDeleteOrder(connection);

        System.out.print(tables);
        //清空数据,以oracle为例
        StringBuilder scrip = new StringBuilder();
        for(String it : tables)
        {
            scrip.append(String.format("delete from %s;\r\n", it));
        }
        System.out.print(scrip);
        //删除所有表,以oracle为例

        for(String it : tables)
        {
            scrip.append(String.format("drop table %s;\r\n", it));
        }
        System.out.print(scrip);

        //提示关闭连接！！！

    }
    public static List getDeleteOrder(Connection connection)
    {
        String userName = null;
        try
        {
            userName = connection.getMetaData().getUserName();
        }
        catch (SQLException e)
        {
            e.printStackTrace();
        }
        return ExportedKeysTools.getDeleteOrder(connection, userName);
    }
    /**
     * 返回清空（删除）数据库表的先后顺序
     * @param connection jdbc连接
     * @param userName 如果为null的话，在oracle数据库下面是所有的用户的所有表。
     * 在mysql下是当前用用户的，这个与数据库厂商的jdbc驱动有关系
     * @return 返回清空（删除）数据库表的先后顺序
     */
    public static List getDeleteOrder(Connection connection,String userName)
    {
        ResultSet reTables = null;
        ResultSet refk = null;
        try
        {
            DatabaseMetaData dm = connection.getMetaData();
            //如果是oracle数据库的话，清空闪回表
            if(dm.getDatabaseProductName().toUpperCase().indexOf("ORACLE")>=0)
            {
                Statement state = connection.createStatement();
                state.execute("PURGE RECYCLEBIN");
                state.close();
            }
            //取得表
            reTables = dm.getTables(null, userName, null, new String[]{"TABLE","VIEW"});
            List tableMetaList = new ArrayList();
            while(reTables.next())
            {
                String tableName = reTables.getString("TABLE_NAME").trim();
                if(tableName == null || tableName.length()<1)
                {
                    continue;
                }
                TableMeta tem = new TableMeta(tableName);
                tableMetaList.add(tem);
                //取得外键表
                refk = dm.getExportedKeys(null, userName, tableName);
                while(refk.next())
                {
                    String fkTableName = refk.getString("FKTABLE_NAME").trim();
                    if(fkTableName == null || fkTableName.length() < 1 ||
                            fkTableName.equals(tableName)) //去掉主外键是自己的小环
                    {
                        continue;
                    }
                    tem.addFK(fkTableName);
                }
                if(refk != null)refk.close();
            }

            Iterator iterator = tableMetaList.iterator();
            TableMeta tableMeta = iterator.next();
            List deleteOrder = new ArrayList();
            int counts = tableMetaList.size();
            for(;true;)
            {
                //没有外键了
                if(!tableMeta.isFKTable())
                {
                    iterator.remove();
                    deleteOrder.add(tableMeta.tableName);

                    //清除表所使用的所有外键表
                    for(TableMeta it : tableMetaList)
                    {
                        it.deleteFK(tableMeta.tableName);
                    }
                }

                if(!iterator.hasNext())
                {
                    //一次循环完成后，如果tableMeta的长度（也不为零）没有减少，
                    //那么说明在tableMeta中的表之间有循环外键关联的“环”，要退出整个循环
                    //不然此处就会有一个死循环，此时在tableMeta中的表的设计也许是有问题的
                    //如果要分析
                    if(tableMetaList.size() == counts || tableMetaList.size() < 1)
                    {
                        break;
                    }
                    iterator = tableMetaList.iterator();
                }
                tableMeta = iterator.next();
            }
           return deleteOrder;
        }
        catch (SQLException e)
        {
            if(refk != null)
                try
                {
                    refk.close();
                }
                catch (SQLException e1)
                {
                    e1.printStackTrace();
                }
            if(reTables != null)
                try
                {
                    reTables.close();
                }
                catch (SQLException e1)
                {
                    e1.printStackTrace();
                }
            e.printStackTrace();
        }
        return null;
    }
    /**
     * 返回外键环
     * @param connection 连接
     * @param userName 用户名，可以为空
     * @return 返回外键环
     */
    public static List getExportedKeysLoop(Connection connection,String userName)
    {
        ResultSet reTables = null;
        ResultSet refk = null;
        try
        {
            DatabaseMetaData dm = connection.getMetaData();
            //如果是oracle数据库的话，清空闪回表
            if(dm.getDatabaseProductName().toUpperCase().indexOf("ORACLE")>=0)
            {
                Statement state = connection.createStatement();
                state.execute("PURGE RECYCLEBIN");
                state.close();
            }
            //取得表
            reTables = dm.getTables(null, userName, null, new String[]{"TABLE","VIEW"});
            List tableMetaList = new ArrayList();
            while(reTables.next())
            {
                String tableName = reTables.getString("TABLE_NAME").trim();
                if(tableName == null || tableName.length()<1)
                {
                    continue;
                }
                TableMeta tem = new TableMeta(tableName);
                tableMetaList.add(tem);
                //取得外键表
                refk = dm.getExportedKeys(null, userName, tableName);
                while(refk.next())
                {
                    String fkTableName = refk.getString("FKTABLE_NAME").trim();
                    if(fkTableName == null || fkTableName.length() < 1 ||
                            fkTableName.equals(tableName)) //去掉主外键是自己的小环
                    {
                        continue;
                    }
                    tem.addFK(fkTableName);
                }
                if(refk != null)refk.close();
            }

            Iterator iterator = tableMetaList.iterator();
            TableMeta tableMeta = iterator.next();
            List exportedKeysLoop = new ArrayList();
            int counts = tableMetaList.size();
            for(;true;)
            {
                //没有外键了
                if(!tableMeta.isFKTable())
                {
                    iterator.remove();
                    //清除表所使用的所有外键表
                    for(TableMeta it : tableMetaList)
                    {
                        it.deleteFK(tableMeta.tableName);
                    }
                }

                if(!iterator.hasNext())
                {
                    //一次循环完成后，如果tableMeta的长度（也不为零）没有减少，
                    //那么说明在tableMeta中的表之间有循环外键关联的“环”，要退出整个循环
                    //不然此处就会有一个死循环，此时在tableMeta中的表的设计也许是有问题的
                    //如果要分析
                    if(tableMetaList.size() == counts || tableMetaList.size() < 1)
                    {
                        for(TableMeta it : tableMetaList)
                        {
                            exportedKeysLoop.add(it.tableName);
                        }
                        break;
                    }
                    iterator = tableMetaList.iterator();
                }
                tableMeta = iterator.next();
            }
           return exportedKeysLoop;
        }
        catch (SQLException e)
        {
            if(refk != null)
                try
                {
                    refk.close();
                }
                catch (SQLException e1)
                {
                    e1.printStackTrace();
                }
            if(reTables != null)
                try
                {
                    reTables.close();
                }
                catch (SQLException e1)
                {
                    e1.printStackTrace();
                }
            e.printStackTrace();
        }
        return null;
    }
    /**
     * 有重复外键的表
     * @param connection 连接
     * @param userName 用户名，可以为空
     * @return 有重复外键的表
     */
    public static List getRepeatExportedKeys(Connection connection,String userName)
    {
        ResultSet reTables = null;
        ResultSet refk = null;
        try
        {
            DatabaseMetaData dm = connection.getMetaData();
            //如果是oracle数据库的话，清空闪回表
            if(dm.getDatabaseProductName().toUpperCase().indexOf("ORACLE")>=0)
            {
                Statement state = connection.createStatement();
                state.execute("PURGE RECYCLEBIN");
                state.close();
            }

            List repeatExportedKeys = new ArrayList();
            //取得表
            reTables = dm.getTables(null, userName, null, new String[]{"TABLE","VIEW"});
            while(reTables.next())
            {
                String tableName = reTables.getString("TABLE_NAME").trim();
                if(tableName == null || tableName.length()<1)
                {
                    continue;
                }
                TableMeta tem = new TableMeta(tableName);
                //取得外键表
                refk = dm.getExportedKeys(null, userName, tableName);
                while(refk.next())
                {
                    String fkTableName = refk.getString("FKTABLE_NAME").trim();
                    if(fkTableName == null || fkTableName.length() < 1)
                    {
                        continue;
                    }
                    if(tem.findFK(fkTableName))
                    {
                        repeatExportedKeys.add(tem.tableName);
                        break;
                    }
                 }
                if(refk != null)refk.close();
            }
           return repeatExportedKeys;
        }
        catch (SQLException e)
        {
            if(refk != null)
                try
                {
                    refk.close();
                }
                catch (SQLException e1)
                {
                    e1.printStackTrace();
                }
            if(reTables != null)
                try
                {
                    reTables.close();
                }
                catch (SQLException e1)
                {
                    e1.printStackTrace();
                }
            e.printStackTrace();
        }
        return null;
    }
    public static class TableMeta{
        //表名
        public String tableName;
        //外键表
        private List fkTable = new ArrayList(1);
        public TableMeta(String table)
        {
            this.tableName = table;
        }
        public boolean findFK(String table)
        {
            return fkTable.contains(table);
        }
        public void deleteFK(String table)
        {
            fkTable.remove(table);
        }
        //是否存在外键表
        public boolean isFKTable()
        {
            return fkTable.size() > 0;
        }
        public void addFK(String table)
        {
            //重名处理
            if(!findFK(table))
            {
                fkTable.add(table);
            }
        }
    }

}

中东 2006-11-09 17:18 发表评论

一个基于gwt的开源项目 -- Dune

中东 — Fri, 04 Aug 2006 08:54:00 GMT

下载：http://sourceforge.net/projects/pdune
说明：基于gwt的项目管理的开源项目

1，实现了像jsp一样的session管理，这一点是相当好的一个参考实现
2，有一个表格的实现
3，对gwt自身的例子参考比较多，比如“sink”等
4，。。。。。。

中东 2006-08-04 16:54 发表评论