struts2學習之旅三權限管理和導航設計

1，權限管理的db設計和dao實現，盡量簡單快速有效；

db的設計如下：權限按照角色來賦給用戶；

權限對應每一個具體的功能，有菜單級別的，有導航級別的，還有頁面級別的功能；

涉及到權限的敏感操作一般都要記錄日志，不僅要記錄到log里還要記錄到遠程的db里，以備審計。學習的時候暫時不用，但是為了全面考

慮設計，這里還是加上；

表名	建表的sql文，這里使用mysql數據庫，因為是學習用的，后面會嘗試用jpa去替換現在的dao，做到對db支持的靈活性
dt_role	DROP TABLE IF EXISTS `dt_role`; CREATE TABLE `dt_role` ( `id` int(11) NOT NULL AUTO_INCREMENT, `roleName` varchar(20) NOT NULL, `roleDesc` varchar(100) DEFAULT NULL, `createDate` datetime DEFAULT NULL, `flag` tinyint(4) DEFAULT NULL, `pid` int(11) DEFAULT NULL, `order` int(11) DEFAULT NULL, `ext` varchar(120) DEFAULT NULL, PRIMARY KEY (`id`) ) ENGINE=InnoDB DEFAULT CHARSET=utf8;
dt_permission	DROP TABLE IF EXISTS `dt_permission`; CREATE TABLE `dt_permission` ( `id` int(11) NOT NULL AUTO_INCREMENT COMMENT '主鍵', `pName` varchar(30) NOT NULL DEFAULT '' COMMENT '權限名稱', `pDesc` varchar(200) DEFAULT NULL COMMENT '權限描述', `pFunctionName` varchar(30) NOT NULL, `pid` int(11) DEFAULT NULL COMMENT '父id', `pUrl` varchar(200) DEFAULT NULL COMMENT '功能的鏈接', `pLevel` tinyint(4) DEFAULT NULL COMMENT '功能的層級', `order` int(11) DEFAULT NULL COMMENT '排序號', `ext` varchar(120) DEFAULT NULL, `createDate` datetime NOT NULL, PRIMARY KEY (`id`) ) ENGINE=InnoDB DEFAULT CHARSET=utf8;
dt_log	DROP TABLE IF EXISTS `dt_log`; CREATE TABLE `dt_log` ( `id` int(11) NOT NULL AUTO_INCREMENT COMMENT '主鍵', `userName` varchar(30) DEFAULT NULL COMMENT '用戶名', `ip` varchar(30) DEFAULT NULL COMMENT 'ip地址', `type` tinyint(4) DEFAULT NULL COMMENT '日志類型', `content` varchar(200) DEFAULT NULL COMMENT '日志內容', `ext1` varchar(120) DEFAULT NULL COMMENT '擴展字段1', `ext2` varchar(120) DEFAULT NULL COMMENT '擴展字段2', `createDate` datetime DEFAULT NULL COMMENT '創建日期', PRIMARY KEY (`id`) ) ENGINE=InnoDB DEFAULT CHARSET=utf8;

向上指數據持久層，采用easydb的方式，先寫基本的dao；

package com.cutter.web.account.dao.achieve;

import java.sql.PreparedStatement; 
import java.sql.ResultSet; 
import java.sql.SQLException; 
import java.util.List;

import org.apache.log4j.Logger; 
import org.pureart.persistement.database.easydb.DB; 
import org.pureart.persistement.database.easydb.IUStH; 
import org.pureart.persistement.database.easydb.ParamReadStH; 
import org.pureart.persistement.database.easydb.ReadStH;

import com.cutter.web.account.dao.entity.Role; 
import com.cutter.web.account.dao.inter.RoleDao; 
import com.cutter.web.account.util.StringUtil; 
import com.google.common.collect.ImmutableList; 
import com.google.common.collect.Lists;

public class RoleDaoAchieve implements RoleDao {

    private static final Logger log = Logger.getLogger(RoleDaoAchieve.class);

    private static final String ROLE_TABLE = " test.dt_role";

    private static final String ROLE_SELECT = " SELECT * FROM " + ROLE_TABLE;

    private static final String ROLE_GET_BY_ID = ROLE_SELECT + " WHERE id=? ;";

    private static final String ROLE_DELETE_BY_ID = " DELETE FROM " + ROLE_TABLE + " WHERE id=? ;";

    private static final String ROLE_LIST_ALL = ROLE_SELECT + " ORDER BY createDate DESC ";

    private static final String ROLE_LIST_BY_PAGE = ROLE_LIST_ALL + " limit ?,? ;";

    private static final String ROLE_ADD = " INSERT INTO " + ROLE_TABLE 
            + " (roleName,roleDesc,flag,pid,order,ext,createDate) VALUES(?,?,?,?,?,?,?);";

    private static final String ROLE_UPDATE = " update " + ROLE_TABLE 
            + " set roleName=? , roleDesc=? , flag=? , pid=? , order=? , ext=? , createDate=? where id=?";

    @Override 
    public boolean update(final Role entity) {

        if (null != entity) { 
            final boolean flag = 0 < entity.getId(); 
            try { 
                return DB.insertUpdate(flag ? ROLE_UPDATE : ROLE_ADD, new IUStH() {

                    @Override 
                    public void handleInsertUpdate(PreparedStatement stmt) throws SQLException { 
                        stmt.setString(1, entity.getRoleName()); 
                        stmt.setString(2, entity.getRoleDesc()); 
                        stmt.setInt(3, entity.getFlag()); 
                        stmt.setInt(4, entity.getPid()); 
                        stmt.setInt(5, entity.getOrder()); 
                        stmt.setString(6, entity.getExt()); 
                        stmt.setDate(7, StringUtil.transforFromUtilToSqlDate(entity.getCrateDate())); 
                        if (flag) { 
                            stmt.setInt(8, entity.getId()); 
                        } 
                        stmt.executeUpdate(); 
                    } 
                }); 
            } catch (SQLException e) { 
                log.error("更新角色信息異常!"); 
                e.printStackTrace(); 
            } 
        } 
        return false; 
    }

    @Override 
    public Role get(final int id) { 
        try { 
            if (0 < id) { 
                final Role role = new Role();

                boolean getResult = DB.select(ROLE_GET_BY_ID, new ParamReadStH() {

                    @Override 
                    public void handleRead(ResultSet rs) throws SQLException {

                        if (rs.next()) { 
                            handResult(role, rs);

                        }

                    }

                    @Override 
                    public void setParams(PreparedStatement stmt) throws SQLException { 
                        stmt.setInt(1, id);

                    } 
                });

                if (getResult) { 
                    return role; 
                } 
            } 
        } catch (SQLException e) { 
            log.error("查詢單條角色信息異常!"); 
            e.printStackTrace(); 
        } 
        return null; 
    }

    @Override 
    public boolean delete(final int id) { 
        try { 
            if (0 < id) { 
                return DB.insertUpdate(ROLE_DELETE_BY_ID, new IUStH() {

                    @Override 
                    public void handleInsertUpdate(PreparedStatement stmt) throws SQLException { 
                        stmt.setInt(1, id); 
                        stmt.executeUpdate(); 
                    } 
                }); 
            } 
        } catch (SQLException e) { 
            log.error("刪除單條角色信息異常!"); 
            e.printStackTrace(); 
        } 
        return false; 
    }

    @Override 
    public boolean batchDelete(final int[] idArray) { 
        try { 
            if (null != idArray && 1 < idArray.length) { 
                return DB.insertUpdate(ROLE_DELETE_BY_ID, new IUStH() {

                    @Override 
                    public void handleInsertUpdate(PreparedStatement stmt) throws SQLException {

                        for (int i : idArray) { 
                            stmt.setInt(1, i); 
                            stmt.addBatch(); 
                        } 
                        stmt.executeBatch(); 
                    } 
                }); 
            } 
        } catch (SQLException e) { 
            log.error("批量刪除角色信息異常!"); 
            e.printStackTrace(); 
        } 
        return false; 
    }

    @Override 
    public ImmutableList<Role> listAll() {

        try { 
            final List<Role> roleList = Lists.newLinkedList();

            boolean listResult = DB.select(ROLE_LIST_ALL, new ReadStH() {

                @Override 
                public void handleRead(ResultSet rs) throws SQLException {

                    while (rs.next()) { 
                        roleList.add(handResult(new Role(), rs)); 
                    } 
                } 
            });

            if (listResult) { 
                return ImmutableList.copyOf(roleList); 
            }

        } catch (SQLException e) { 
            log.error("查詢全部角色信息異常!"); 
            e.printStackTrace(); 
        }

        return null; 
    }

    @Override 
    public ImmutableList<Role> list(final int pageSize, final int page) {

        try {

            final List<Role> roleLists = Lists.newLinkedList();

            boolean listPageResult = DB.select(ROLE_LIST_BY_PAGE, new ParamReadStH() {

                @Override 
                public void handleRead(ResultSet rs) throws SQLException {

                    while (rs.next()) { 
                        roleLists.add(handResult(new Role(), rs)); 
                    }

                }

                @Override 
                public void setParams(PreparedStatement stmt) throws SQLException { 
                    int start = pageSize * (page - 1); 
                    int end = start + pageSize;

                    stmt.setInt(1, start); 
                    stmt.setInt(2, end); 
                } 
            });

            if (listPageResult) { 
                return ImmutableList.copyOf(roleLists); 
            }

        } catch (SQLException e) { 
            log.error("分頁查詢角色信息異常!"); 
            e.printStackTrace(); 
        }

        return null;

    }

    private Role handResult(final Role role, ResultSet rs) throws SQLException { 
        
        role.setId(rs.getInt("id")); 
        role.setRoleName(rs.getString("roleName")); 
        role.setRoleDesc(rs.getString("roleDesc")); 
        role.setPid(rs.getInt("pid")); 
        role.setFlag(rs.getInt("flag")); 
        role.setCrateDate(StringUtil.transforFromSqlToUtilDate(rs.getDate("createDate"))); 
        role.setExt(rs.getString("ext")); 
        role.setOrder(rs.getInt("order"));

        return role; 
    }

}

View Code

package com.cutter.web.account.dao.achieve;

import java.sql.PreparedStatement; 
import java.sql.ResultSet; 
import java.sql.SQLException; 
import java.util.List;

import org.apache.log4j.Logger; 
import org.pureart.persistement.database.easydb.DB; 
import org.pureart.persistement.database.easydb.IUStH; 
import org.pureart.persistement.database.easydb.ParamReadStH; 
import org.pureart.persistement.database.easydb.ReadStH;

import com.cutter.web.account.dao.entity.Permission; 
import com.cutter.web.account.dao.inter.PermissionDao; 
import com.cutter.web.account.util.StringUtil; 
import com.google.common.collect.ImmutableList; 
import com.google.common.collect.Lists;

public class PermissionDaoAchieve implements PermissionDao {

    private static final Logger log = Logger.getLogger(PermissionDaoAchieve.class);

    private static final String PERMISSION_TABLE = " test.dt_permission ";

    private static final String PERMISSION_SELECT = " SELECT * FROM  " + PERMISSION_TABLE;

    private static final String PERMISSION_GET_BY_ID = PERMISSION_SELECT + " where id=? ;"; 
    
    private static final String PERMISSION_GET_BY_ROLEID = PERMISSION_SELECT + " where roleId=? ;";

    private static final String PERMISSION_DELETE_BY_ID = " DELETE FROM " + PERMISSION_TABLE + " WHERE id=? ;";

    private static final String PERMISSION_LIST_ALL = PERMISSION_SELECT + " ORDER BY createDate DESC ;";

    private static final String PERMISSION_LIST_BY_PAGE = PERMISSION_LIST_ALL + " LIMIT ?,? ; ";

    private static final String PERMISSION_ADD = " INSERT INTO " + PERMISSION_TABLE 
            + " (pName,pFunctionName,pid,pDesc,pUrl,pLevel,order,ext,createDate) VALUES(?,?,?,?,?,?,?,?,?,?)";

    private static final String PERMISSION_UPDATE = " UPDATE " 
            + PERMISSION_TABLE 
            + " SET pName=? , pFunctionName=? , pid=? , pDesc=? , pUrl=? , pLevel=? , order=? , ext=? , createDate=? where id=? ;";

    @Override 
    public boolean update(final Permission entity) { 
        if (null != entity) { 
            try { 
                final boolean flag = 0 < entity.getId();

                DB.insertUpdate(flag ? PERMISSION_UPDATE : PERMISSION_ADD, new IUStH() {

                    @Override 
                    public void handleInsertUpdate(PreparedStatement stmt) throws SQLException {

                        stmt.setString(1, entity.getpName()); 
                        stmt.setString(2, entity.getpFunctionName()); 
                        stmt.setInt(3, entity.getPid()); 
                        stmt.setString(4, entity.getpDesc()); 
                        stmt.setString(5, entity.getpUrl()); 
                        stmt.setInt(6, entity.getpLevel()); 
                        stmt.setInt(7, entity.getOrder()); 
                        stmt.setString(8, entity.getExt()); 
                        stmt.setDate(9, StringUtil.transforFromUtilToSqlDate(entity.getCreateDate()));

                        if (flag) { 
                            stmt.setInt(10, entity.getId()); 
                        } 
                        stmt.executeUpdate();

                    } 
                }); 
            } catch (SQLException e) { 
                log.error("更新權限信息異常!"); 
                e.printStackTrace(); 
            } 
        } 
        return false; 
    }

    @Override 
    public Permission get(final int id) {

        if (0 < id) { 
            final Permission permission = new Permission(); 
            try { 
                boolean getResult = DB.select(PERMISSION_GET_BY_ID, new ParamReadStH() {

                    @Override 
                    public void handleRead(ResultSet rs) throws SQLException { 
                        if (rs.next()) { 
                            handResult(permission, rs); 
                        }

                    }

                    @Override 
                    public void setParams(PreparedStatement stmt) throws SQLException { 
                        stmt.setInt(1, id);

                    } 
                });

                if (getResult) { 
                    return permission; 
                } 
            } catch (SQLException e) { 
                log.error("查詢單條的權限信息異常!"); 
                e.printStackTrace(); 
            } 
        }

        return null; 
    }

    @Override 
    public boolean delete(final int id) { 
        if (0 < id) { 
            try { 
                return DB.insertUpdate(PERMISSION_DELETE_BY_ID, new IUStH() {

                    @Override 
                    public void handleInsertUpdate(PreparedStatement stmt) throws SQLException { 
                        stmt.setInt(1, id); 
                        stmt.executeUpdate(); 
                    } 
                }); 
            } catch (SQLException e) { 
                log.error("刪除單條的權限信息異常!"); 
                e.printStackTrace(); 
            } 
        }

        return false; 
    }

    @Override 
    public boolean batchDelete(final int[] idArray) { 
        if (null != idArray && 1 < idArray.length) { 
            try { 
                return DB.insertUpdate(PERMISSION_DELETE_BY_ID, new IUStH() {

                    @Override 
                    public void handleInsertUpdate(PreparedStatement stmt) throws SQLException { 
                        for (int i : idArray) { 
                            stmt.setInt(1, i); 
                            stmt.addBatch(); 
                        } 
                        stmt.executeBatch(); 
                    } 
                }); 
            } catch (SQLException e) { 
                log.error("批量刪除權限信息異常!"); 
                e.printStackTrace(); 
            } 
        }

        return false; 
    }

    @Override 
    public ImmutableList<Permission> listAll() {

        final List<Permission> permissionList = Lists.newLinkedList();

        boolean listResult; 
        try { 
            listResult = DB.select(PERMISSION_LIST_ALL, new ReadStH() {

                @Override 
                public void handleRead(ResultSet rs) throws SQLException { 
                    while (rs.next()) { 
                        permissionList.add(handResult(new Permission(), rs)); 
                    }

                } 
            }); 
            if (listResult) { 
                return ImmutableList.copyOf(permissionList); 
            }

        } catch (SQLException e) { 
            log.error("查詢所有的權限信息異常!"); 
            e.printStackTrace(); 
        }

        return null; 
    }

    @Override 
    public ImmutableList<Permission> list(final int pageSize, final int page) { 
        final List<Permission> permissionList = Lists.newLinkedList();

        boolean listResult; 
        try { 
            listResult = DB.select(PERMISSION_LIST_ALL, new ParamReadStH() { 
                @Override 
                public void handleRead(ResultSet rs) throws SQLException { 
                    while (rs.next()) { 
                        permissionList.add(handResult(new Permission(), rs)); 
                    }

                }

                @Override 
                public void setParams(PreparedStatement stmt) throws SQLException { 
                    int start = pageSize * (page - 1); 
                    int end = start + pageSize;

                    stmt.setInt(1, start); 
                    stmt.setInt(2, end);

                } 
            }); 
            if (listResult) { 
                return ImmutableList.copyOf(permissionList); 
            }

        } catch (SQLException e) { 
            log.error("分頁查詢權限信息異常!"); 
            e.printStackTrace(); 
        }

        return null; 
    }

    private Permission handResult(final Permission permission, ResultSet rs) throws SQLException { 
        permission.setId(rs.getInt("id")); 
        permission.setpName(rs.getString("pName")); 
        permission.setpDesc(rs.getString("pDesc")); 
        permission.setOrder(rs.getInt("order")); 
        permission.setCreateDate(StringUtil.transforFromSqlToUtilDate(rs.getDate("createDate"))); 
        permission.setpFunctionName(rs.getString("pFunctionName")); 
        permission.setExt(rs.getString("ext")); 
        permission.setPid(rs.getInt("pid")); 
        permission.setpLevel(rs.getInt("pLevel")); 
        permission.setpUrl(rs.getString("pUrl"));

        return permission; 
    }

    @Override 
    public ImmutableList<Permission> getPermissionsByRoleId(final int roleId) { 
        if (0 < roleId) { 
            final List<Permission> permissions = Lists.newLinkedList(); 
            try { 
                boolean getResult = DB.select(PERMISSION_GET_BY_ROLEID, new ParamReadStH() {

                    @Override 
                    public void handleRead(ResultSet rs) throws SQLException { 
                        while (rs.next()) { 
                            permissions.add(handResult(new Permission(), rs)); 
                        }

                    }

                    @Override 
                    public void setParams(PreparedStatement stmt) throws SQLException { 
                        stmt.setInt(1, roleId);

                    } 
                });

                if (getResult) { 
                    return ImmutableList.copyOf(permissions); 
                } 
            } catch (SQLException e) { 
                log.error("根據角色查詢權限信息異常!"); 
                e.printStackTrace(); 
            } 
        }

        return null; 
    }

}

View Code

package com.cutter.web.account.dao.achieve;

import java.sql.PreparedStatement; 
import java.sql.ResultSet; 
import java.sql.SQLException; 
import java.util.List;

import org.apache.log4j.Logger; 
import org.apache.tiles.jsp.taglib.InsertAttributeTag; 
import org.pureart.persistement.database.easydb.DB; 
import org.pureart.persistement.database.easydb.IUStH; 
import org.pureart.persistement.database.easydb.ParamReadStH; 
import org.pureart.persistement.database.easydb.ReadStH;

import com.cutter.web.account.dao.entity.Log; 
import com.cutter.web.account.dao.inter.LogDao; 
import com.cutter.web.account.util.StringUtil; 
import com.google.common.collect.ImmutableList; 
import com.google.common.collect.Lists;

public class LogDaoAchieve implements LogDao {

    private static final Logger log = Logger.getLogger(LogDaoAchieve.class);

    private static final String LOG_TABLE = " test.dt_log ";

    private static final String LOG_SELECT = " SELECT * FROM " + LOG_TABLE;

    private static final String LOG_GET_BY_ID = LOG_SELECT + " WHERE id=? ;";

    private static final String LOG_DELETE_BY_ID = " DELETE FROM " + LOG_TABLE + " WHERE id=? ;";

    private static final String LOG_LIST_ALL = LOG_SELECT + " ORDER BY createDate DESC ;";

    private static final String LOG_LIST_ALL_BY_PAGE = LOG_SELECT + " ORDER BY createDate DESC limit ?,? ;";

    private static final String LOG_LIST_ALL_BY_TYPE = LOG_SELECT + " WHERE type=? ;";

    private static final String LOG_ADD = " INSERT INTO " + LOG_TABLE 
            + " (userName,ip,type,content,createDate,ext1,ext2) VALUES(?,?,?,?,?,?,?) ;";

    private static final String LOG_UPDATE = " UPDATE " + LOG_TABLE 
            + " SET userName=? , ip=? , type=? , content=? , createDate=? , ext1=? , ext2=? WHERE id=? ;";

    @Override 
    public boolean update(final Log entity) {

        if (null != entity) { 
            try { 
                final boolean flag = 0 < entity.getId();

                return DB.insertUpdate(flag ? LOG_UPDATE : LOG_ADD, new IUStH() {

                    @Override 
                    public void handleInsertUpdate(PreparedStatement stmt) throws SQLException { 
                        stmt.setString(1, entity.getUserName()); 
                        stmt.setString(2, entity.getIp()); 
                        stmt.setInt(3, entity.getType()); 
                        stmt.setString(4, entity.getContent()); 
                        stmt.setDate(5, StringUtil.transforFromUtilToSqlDate(entity.getCreateDate())); 
                        stmt.setString(6, entity.getExt1()); 
                        stmt.setString(7, entity.getExt2()); 
                        if (flag) { 
                            stmt.setInt(8, entity.getId()); 
                        } 
                        stmt.executeUpdate();

                    } 
                });

            } catch (SQLException e) { 
                log.error("更新用戶日志異常!"); 
                e.printStackTrace(); 
            } 
        }

        return false; 
    }

    @Override 
    public Log get(final int id) { 
        try { 
            final Log log = new Log(); 
            boolean selectResult = DB.select(LOG_GET_BY_ID, new ParamReadStH() {

                @Override 
                public void handleRead(ResultSet rs) throws SQLException { 
                    if (rs.next()) { 
                        handleResult(log, rs); 
                    } 
                }

                @Override 
                public void setParams(PreparedStatement stmt) throws SQLException { 
                    stmt.setInt(1, id); 
                } 
            });

            if (selectResult) { 
                return log; 
            }

        } catch (SQLException e) { 
            log.error("查詢單條的日志信息異常!"); 
            e.printStackTrace(); 
        }

        return null; 
    }

    @Override 
    public boolean delete(final int id) {

        try { 
            if (0 < id) { 
                return DB.insertUpdate(LOG_DELETE_BY_ID, new IUStH() {

                    @Override 
                    public void handleInsertUpdate(PreparedStatement stmt) throws SQLException { 
                        stmt.setInt(1, id); 
                        stmt.executeUpdate(); 
                    } 
                }); 
            } 
        } catch (SQLException e) { 
            log.error("刪除用戶日志異常!"); 
            e.printStackTrace(); 
        } 
        return false; 
    }

    @Override 
    public boolean batchDelete(final int[] idArray) {

        try { 
            if (null != idArray && 1 <= idArray.length) { 
                return DB.insertUpdate(LOG_DELETE_BY_ID, new IUStH() {

                    @Override 
                    public void handleInsertUpdate(PreparedStatement stmt) throws SQLException {

                        for (int i : idArray) { 
                            stmt.setInt(1, i); 
                            stmt.addBatch(); 
                        } 
                        stmt.executeBatch();

                    } 
                }); 
            } 
        } catch (SQLException e) { 
            log.error("批量刪除日志異常!"); 
            e.printStackTrace(); 
        }

        return false; 
    }

    @Override 
    public ImmutableList<Log> listAll() { 
        final List<Log> logList = Lists.newLinkedList(); 
        try { 
            final boolean listResult = DB.select(LOG_LIST_ALL, new ReadStH() {

                @Override 
                public void handleRead(ResultSet rs) throws SQLException { 
                    while (rs.next()) { 
                        logList.add(handleResult(new Log(), rs)); 
                    } 
                } 
            });

            if (listResult) { 
                return ImmutableList.copyOf(logList); 
            }

        } catch (SQLException e) { 
            log.error("查詢所有的日志異常!"); 
            e.printStackTrace(); 
        }

        return null; 
    }

    @Override 
    public ImmutableList<Log> list(final int pageSize, final int page) { 
        try { 
            if (0 < page && 0 < pageSize) { 
                final List<Log> logList = Lists.newLinkedList(); 
                final boolean listResult = DB.select(LOG_LIST_ALL_BY_PAGE, new ParamReadStH() {

                    @Override 
                    public void handleRead(ResultSet rs) throws SQLException { 
                        while (rs.next()) { 
                            logList.add(handleResult(new Log(), rs)); 
                        } 
                    }

                    @Override 
                    public void setParams(PreparedStatement stmt) throws SQLException { 
                        int start = pageSize * (page - 1); 
                        int end = start + pageSize; 
                        stmt.setInt(1, start); 
                        stmt.setInt(2, end); 
                    } 
                });

                if (listResult) { 
                    return ImmutableList.copyOf(logList); 
                }

            }

        } catch (SQLException e) { 
            log.error("分頁查詢日志異常!"); 
            e.printStackTrace(); 
        }

        return null; 
    }

    @Override 
    public ImmutableList<Log> getLogByType(final int typeId) { 
        final List<Log> logList = Lists.newLinkedList(); 
        try { 
            final boolean listResult = DB.select(LOG_LIST_ALL, new ParamReadStH() {

                @Override 
                public void handleRead(ResultSet rs) throws SQLException { 
                    while (rs.next()) { 
                        logList.add(handleResult(new Log(), rs)); 
                    } 
                }

                @Override 
                public void setParams(PreparedStatement stmt) throws SQLException { 
                    stmt.setInt(1, typeId);

                } 
            });

            if (listResult) { 
                return ImmutableList.copyOf(logList); 
            }

        } catch (SQLException e) { 
            log.error("根據類型id查詢日志異常!"); 
            e.printStackTrace(); 
        }

        return null; 
    }

    private Log handleResult(final Log log, ResultSet rs) throws SQLException {

        log.setId(rs.getInt("id")); 
        log.setUserName(rs.getString("userName")); 
        log.setIp(rs.getString("ip")); 
        log.setContent(rs.getString("content")); 
        log.setCreateDate(StringUtil.transforFromSqlToUtilDate(rs.getDate("createDate"))); 
        log.setType(rs.getInt("type")); 
        log.setExt1(rs.getString("ext1")); 
        log.setExt2(rs.getString("ext2"));

        return log; 
    }

}

View Code

開玩笑這么枯燥重復的代碼我硬是耐著性子花了一個半小時碼完，真的服了自己，必須盡快找個簡單易用的jpa框架來解放一下自己。

2，界面設計和導航

做出來的界面先照個面；

主要是在跳轉到主頁的時候，給出右側導航欄的數據，然后使用tiles布局，實現頁面的導航，基本完成了任務；下面貼出要點；

要點	說明
導航數據提取，初始化導航欄的時候先初始化菜單級別的權限，然后是導航級別的；到頁面的時候設置一個攔截器，如果用戶有權限，顯示并導航，沒有則攔截并隱藏；	private List<PermissionTreeNode> handlePermission(ImmutableList<PermissionEntity> permissions) { if(null!=permissions&&!permissions.isEmpty()) { List<PermissionTreeNode> tree=Lists.newLinkedList(); //1，篩選出菜單項 Collection<PermissionEntity> menuCollection= Collections2.filter(permissions, new Predicate<PermissionEntity>() { @Override public boolean apply(PermissionEntity input) { return input.getpLevel()==1; } }); if(null!=menuCollection&&!menuCollection.isEmpty()) { //2,組裝成樹型結構 for (final PermissionEntity menuItem : menuCollection) { PermissionTreeNode node=new PermissionTreeNode(); node.setPid(menuItem.getId()); node.setpName(menuItem.getpName()); node.setChildren(Collections2.filter(permissions, new Predicate<PermissionEntity>() { @Override public boolean apply(PermissionEntity input) { return input.getPid()==menuItem.getId()&&input.getpLevel()==2; } })); tree.add(node); } return tree; } } return null; }
導航數據的構造，這里使用的是方法取得屬性，使用成員變量名取不到，不知道是為什么，下次搞清楚了再貼出來；	<div style="background-color:gray;text-align: center;"> <h1>導航</h1> <hr> <s:iterator id="item" value="#session.permission" var="item"> <div> <span><s:property value="#item.getpName()" /> </span> <s:iterator var="navItem" value="#item.getChildren()"> <br><a href="<%=contextPath%><s:property value="#navItem.getpUrl()" /> "> <s:property value="#navItem.getpName()" /> </a> </s:iterator> </div> </s:iterator> </div>
tiles組件配置，這里搞了一個title，算是人性化一點；	<?xml version="1.0" encoding="UTF-8"?> <!DOCTYPE tiles-definitions PUBLIC "-//Apache Software Foundation//DTD Tiles Configuration 2.0//EN" "http://tiles.apache.org/dtds/tiles-config_2_0.dtd"> <tiles-definitions> <definition name="adminHomePage" extends="adminDefaultLayout"> <put-attribute name="titleKey" value="cutter哥哥后臺管理主頁"/> <put-attribute name="content" value="/manager/index.jsp" /> </definition> <definition name="listUserPage" extends="adminDefaultLayout"> <put-attribute name="titleKey" value="查詢用戶"/> <put-attribute name="content" value="/manager/user/userList.jsp" /> </definition> <definition name="addUserPage" extends="adminDefaultLayout"> <put-attribute name="titleKey" value="增加用戶"/> <put-attribute name="content" value="/manager/user/addList.jsp" /> </definition> <definition name="editUserPage" extends="adminDefaultLayout"> <put-attribute name="titleKey" value="編輯用戶"/> <put-attribute name="content" value="/manager/user/editList.jsp" /> </definition> </tiles-definitions>
優化了一下布局，作為后臺開發人員，前端的布局和樣式實在是有待加強，見諒；	<style type="text/css"> body { text-decoration: none; width: 100%; height: 100%; text-align: center; } .head { width: 100%; height: 50px; background-color: green; } .bottom { width: 100%; height: 30px; background-color: green; } .leftBox { width: 100px; height: 600px; background-color: green; clear:both; float: left; } .content { width: 90%; height: 600px; clear: right; margin-left: 100px; margin-top: 50px; } </style>

3，struts2的流程原理跟蹤

要開發高效耐用的站點，并在站點出現問題的時候及時的補救，了解站點的啟動和運行過程是很有必要的，現在手上的這個小demo規模很小，

我忍不住想要知道它到底是怎么啟動和運行的，struts2這個萬能代理到底起到一個神馬作用；結合開始自學的那個圖，來跟蹤站點的啟動和

運行過程；

站點的啟動過程，tomcat啟動之后，開始部署站，比如說要部署我的小站，首先它會找到WEB-INF,把下面的jar包先加載完，之后是一般的java代碼，

Jsp轉換之后的java代碼，靜態資源等（這是個猜想，之后我會去看看tomcat的核心代碼，看看它的運行機制到底是不是這樣的？）

看tomcat的啟動日志可見一斑；

站點啟動過程：個人通過源碼分析；

tiles的啟動細節分析：

要點

代碼分析

tiles的啟動過程

1，首先，得到ServletContext對象；通過tomcat的啟動事件得到；

2，得到tiler容器，通過ServletContext構造；
如果ServletContext不含有key為TilesContainerFactory.CONTEXT_FACTORY_INIT_PARAM（
public static final String CONTEXT_FACTORY_INIT_PARAM =
        "org.apache.tiles.context.TilesContextFactory";）的配置，裝飾一個；
if(context.getInitParameter(TilesContainerFactory.CONTEXT_FACTORY_INIT_PARAM) == null) {
            context = decorate(context);
        }
        else {
            if (LOG.isWarnEnabled()) {
            LOG.warn("Tiles container factory is explicitly set. Not injecting struts configuration.");
            }
        }
        return super.createContainer(context);

裝飾過程如下：
protected ServletContext decorate(ServletContext context) {
        return new ConfiguredServletContext(context, INIT);
    }
直接使用現有的ServletContext和一個空的map實例化一個，作為ServletContext；
然后調用父類的工廠，創建一個容器；創建過程如下：
public TilesContainer createTilesContainer(Object context)
        throws TilesException {
        BasicTilesContainer container = new BasicTilesContainer();
        initializeContainer(context, container);
        return container;
    }
先創建一個基本的tiles容器，然后使用ServletContext初始化；

一切準備工作做好之后會打出一個log：Initializing Tiles2 container. . .

然后會初始化定義的配置文件，一個一個的加載到內存；
DEBUG - Adding resource 'jndi:/localhost/sq/WEB-INF/tiles/tiles.xml' to definitions factory.
DEBUG - Adding resource 'jndi:/localhost/sq/WEB-INF/tiles/tiles-adminUser.xml' to definitions factory.
得到一個讀取配置文件的對象：
DEBUG - register('-//Apache Software Foundation//DTD Tiles Configuration 2.0//EN', 'jar:file:/E:/evn/tomcat7-32or64/webapps/sq/WEB-INF/lib/tiles-cor
最后讀取配置文件，找到tiles屬性對應的文件，最后是初始化好定義的tiles組件；

BUG - Popping body text ''
DEBUG - endDocument()
DEBUG - Resolve definition for child name='addUserPage' extends='adminDefaultLayout'.
DEBUG - Resolve definition for child name='adminHomePage' extends='adminDefaultLayout'.
DEBUG - Resolve definition for child name='editUserPage' extends='adminDefaultLayout'.
DEBUG - Resolve definition for child name='listUserPage' extends='adminDefaultLayout'.

最后把tiles容器發不到服務器的上下文；

struts2的過濾器的啟動過程

struts2的初始化過程：
public void init(FilterConfig filterConfig) throws ServletException {
        InitOperations init = new InitOperations();
        try {
            FilterHostConfig config = new FilterHostConfig(filterConfig);
            init.initLogging(config);
           Dispatcher dispatcher = init.initDispatcher(config);
            init.initStaticContentLoader(config, dispatcher);

            prepare = new PrepareOperations(filterConfig.getServletContext(), dispatcher);
            execute = new ExecuteOperations(filterConfig.getServletContext(), dispatcher);
            this.excludedPatterns = init.buildExcludedPatternsList(dispatcher);

            postInit(dispatcher, filterConfig);
        } finally {
            init.cleanup();
        }
    }

首先得到過濾器的配置文件，接著初始化日志,
然后加載struts的配置文件到內存，完成url和Action的映射（紅色部分）；

快下班了明天再分析紅色的那部分代碼；

最后是把控制權交還給tomcat的線程，完成tomcat的啟動；

站點的運行過程放到下一節來說，晚上還有籃球賽，血戰研發1，加油·············

4，小結

按照一般的后臺的需求，模擬完成了兩個功能，導航設計和權限管理，然后跟蹤了一遍站點的啟動和運行過程，加深了對struts2的理解；最后

奉上一個搞笑的圖片，希望天天開心，保持好的心態；

posted @ 2013-06-18 18:35 李福春閱讀(4607) 評論(0) 收藏舉報

刷新頁面返回頂部

every day is another day!

用代碼解決問題,用代碼書寫生活.coding for my life.

struts2學習之旅三權限管理和導航設計

公告

every day is another day!

用代碼解決問題,用代碼書寫生活.coding for my life.

struts2學習之旅三 權限管理和導航設計

公告

struts2學習之旅三權限管理和導航設計