J2EE项目之整合Struts+Hibernate开发电子留言系统

 

 

 

 

 

本电子留言系统采用J2SDK1.5.0_14＋Tomcat5.5.25 ＋MyEclipse5.5.1GA＋MySQL5.0.45＋Struts1.2.9＋Hibernate3.1.2开发。

一、系统架构说明

i.架构说明

虽然本系统没有引入Spring框架，但本项目依然示范了一个优秀的J2EE项目架构，因此，中间层由MVC控制层、业务逻辑组件层、DAO组件层三层组成。系统通过DAO组件进行持久层访问；而用户的请求则只负责与MVC控制器层交互；业务逻辑组件则向上与控制器交互，向下与DAO组件交互

ii.实现自己的DAO层

应用中DAO组件、业务逻辑组件的管理，业务逻辑组件如何定位DAO组件，控制器如何定位业务逻辑组件。

iii.事务的控制

对于一个理想的J2EE应用而言，业务逻辑层不应该出现持久层API。即业务逻辑层组件不再与Hibernate API耦合。抽取所有的事务代码，利用代理模式来为系统中的业务逻辑组件生成事务代理，系统的控制组件则改为依赖于业务逻辑组件的事务代理。

二、系统概要设计

i.确定系统功能

本系统主要包含如下几个最简单但又最基础的基本功能：

用户注册；用户登录；用户留言；用户查看留言

ii.提取用户实体

系统模块划分：MessageManager组件-->UserDao组件-->User持久化对象-->User数据表；MessageManager组件-->MessageDao组件-->Message持久化对象-->Message数据表

三、实现Hibernate持久层

i.Hibernate持久层的POJO

 

package  org.prolove.model;

import  java.util.Set;
import  java.util.HashSet;

public   class  User
... {
    private int id;
    private String name;
    private String pass;

    private Set<Message> messages = new HashSet<Message>();
    
    public void setId(int id) ...{
        this.id = id; 
    }

    public void setName(String name) ...{
        this.name = name; 
    }

    public void setPass(String pass) ...{
        this.pass = pass; 
    }
    
    public void setMessages(Set<Message> messages) ...{
        this.messages = messages; 
    }    

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

    public String getName() ...{
        return (this.name); 
    }

    public String getPass() ...{
        return (this.pass); 
    }

    public Set<Message> getMessages()...{
        return (this.messages);
    }
}

 

package  org.prolove.model;

public   class  Message
... {
    private int id;
    private String title;
    private String content;

    private User user;

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

    public void setTitle(String title) ...{
        this.title = title; 
    }

    public void setContent(String content) ...{
        this.content = content; 
    }

    public void setUser(User user) ...{
        this.user = user; 
    }

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

    public String getTitle() ...{
        return (this.title); 
    }

    public String getContent() ...{
        return (this.content); 
    }

    public User getUser() ...{
        return (this.user); 
    }


}

ii.编写PO的映射配置文件

User.hbm.xml

<? xml version="1.0" encoding="GBK" ?>
<! DOCTYPE hibernate-mapping PUBLIC
        "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
        "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd" >
< hibernate-mapping  package ="org.prolove.model" >
     <!--  每个class元素映射一个持久化类  -->
     < class  name ="User"  table ="user_table" >
         < id  name ="id" >
             < generator  class ="identity" />
         </ id >
         < property  name ="name"  unique ="true" />
         < property  name ="pass" />
         < set  name ="messages"   inverse ="true" >
             < key  column ="owner_id" />
             < one-to-many  class ="Message" />
         </ set >
     </ class >
</ hibernate-mapping >

Message.hbm.xml

<? xml version="1.0" encoding="GBK" ?>
<! DOCTYPE hibernate-mapping PUBLIC
        "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
        "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd" >
< hibernate-mapping  package ="org.prolove.model" >
     <!--  每个class元素映射一个持久化类  -->
     < class  name ="Message"  table ="message_table" >
         < id  name ="id" >
             < generator  class ="identity" />
         </ id >
         < property  name ="title" />
         < property  name ="content" />
         < many-to-one  name ="user"  column ="owner_id"  not-null ="true" />
     </ class >
</ hibernate-mapping >

iii.连接数据库

hibernate.cfg.xml

<? xml version='1.0' encoding='utf-8' ?>
<! DOCTYPE hibernate-configuration PUBLIC
        "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
        "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd" >

< hibernate-configuration >

     < session-factory >

         <!--  Database connection settings  -->
         < property  name ="connection.driver_class" > com.mysql.jdbc.Driver </ property >
         < property  name ="connection.url" > jdbc:mysql://localhost/message </ property >
         < property  name ="connection.username" > root </ property >
         < property  name ="connection.password" > root </ property >

         <!--  C3P0 connection pool   -->
         < property  name ="hibernate.c3p0.max_size" > 25 </ property >
         < property  name ="hibernate.c3p0.min_size" > 1 </ property >
         < property  name ="hibernate.c3p0.timeout" > 5000 </ property >
         < property  name ="hibernate.c3p0.max_statements" > 100 </ property >
         < property  name ="hibernate.c3p0.idle_test_period" > 3000 </ property >
         < property  name ="hibernate.c3p0.acquire_increment" > 2 </ property >
         < property  name ="hibernate.c3p0.validate" > true </ property >

         <!--  SQL dialect  -->
         < property  name ="dialect" > org.hibernate.dialect.MySQLDialect </ property >

         <!--  Echo all executed SQL to stdout  -->
         < property  name ="show_sql" > false </ property >

         <!--  Drop and re-create the database schema on startup  -->
         < property  name ="hbm2ddl.auto" > update </ property >

         < mapping  resource ="Message.hbm.xml" />
         < mapping  resource ="User.hbm.xml" />

     </ session-factory >

</ hibernate-configuration >

iv.(附加)资源文件

message.properties

# Errors
errors.footer = 出错啦！
errors.header = <h3><font color = " red " >出错提示：</font></h3>您必须完成如下提示，才可继续进行：
errors.ioException = I/O exception rendering error messages: { 0 }
error.database.missing = <li>User database is missing ,  cannot validate logon credentials</li>
errors.required = { 0 } 必须填写。
errors.minlength = { 0 } 字符长度必须大于 { 1 } 个字符。
errors.maxlength = { 0 } 字符长度必须小于 { 1 } 字符。
errors.invalid = { 0 } 无效.

html.li.open = <li>
html.li.close = </li>
file.location = The { 0 } file for this page can be found in the { 1 } directory.

errors.byte = { 0 } 必须是个字节型变量。
errors.short = { 0 } 必须是个短整型变量。
errors.integer = { 0 } 必须是个整型变量。
errors.long = { 0 } 必须是个长整型变量。
errors.float = { 0 } 必须是个单精度浮点型变量。
errors.double = { 0 } 必须是个双精度浮点型变量。

errors.date = { 0 } 必须是个日期。

errors.range = { 0 } 必须大于{ 1 }，并小于{ 2 }。

errors.creditcard = { 0 } 必须是个有效的信用卡卡号。

errors.email = { 0 } 必须是个有效的Email地址。
errors.url = { 0 } 必须是个有效的URL地址。

# Exception
MessageException = 系统业务逻辑异常:{ 0 }

#登陆表单
loginForm.user = 登陆的用户名
loginForm.pass = 登陆的密码

#发表留言表单
postMessageForm.title = 留言标题
postMessageForm.content = 留言内容

#注册表单
registForm.user = 注册的用户名
registForm.pass = 注册的密码

四、DAO组件层

i.DAO模式的结构

DAO接口；DAO实现类；DAO工厂

ii.编写DAO接口

package  org.prolove.dao;

import  org.prolove.model. * ;
import  org.hibernate.Session;

import  java.util. * ;

public   interface  UserDao
... {

    /** *//**
     * 根据主键加载用户
     * @param id 需要加载的用户ID
     * @param sess 持久化操作所需要的Hiberate Session
     * @return 加载的用户
     */
    User get(Session sess , int id);

    /** *//**
     * 保存用户
     * @param u 需要保存的用户
     * @param sess 持久化操作所需要的Hiberate Session
     * @return 保存用户的主键
     */
    int save(Session sess , User u);

    /** *//**
     * 删除用户
     * @param sess 持久化操作所需要的Hiberate Session
     * @param u 需要删除的用户
     */
    void delete(Session sess , User u);

    /** *//**
     * 删除用户
     * @param sess 持久化操作所需要的Hiberate Session
     * @param id 需要删除的用户的id
     */
    void delete(Session sess , int id);

    /** *//**
     * 修改用户
     * @param sess 持久化操作所需要的Hiberate Session
     * @param u 需要修改的用户
     */
    void update(Session sess , User u);

    /** *//**
     * 根据用户名查找用户
     * @param sess 持久化操作所需要的Hiberate Session
     * @param name 需要查找的用户的用户名
     * @return 查找到的用户
     */
    User findByName(Session sess , String name);
}

 

package  org.prolove.dao;

import  org.prolove.model. * ;
import  org.hibernate.Session;


import  java.io.Serializable;
import  java.util.List;

public   interface  MessageDao
... {
    /** *//**
     * 根据主键加载消息
     * @param sess 持久化操作所需要的Hiberate Session
     * @param id 需要加载的消息ID
     * @return 加载的消息
     */
    Message get(Session sess , int id);

    /** *//**
     * 保存消息
     * @param sess 持久化操作所需要的Hiberate Session
     * @param m 需要保存的消息
     * @retun 保存消息的主键
     */
    int save(Session sess , Message m);

    /** *//**
     * 删除消息
     * @param sess 持久化操作所需要的Hiberate Session
     * @param m 需要删除的消息
     */
    void delete(Session sess , Message m);

    /** *//**
     * 删除消息
     * @param sess 持久化操作所需要的Hiberate Session
     * @param id 需要删除的消息ID
     */
    void delete(Session sess , int id);

    /** *//**
     * 修改消息
     * @param sess 持久化操作所需要的Hiberate Session
     * @param m 需要修改的消息
     */
    void update(Session sess , Message m);

    /** *//**
     * 查询指定用户、指定页的消息
     * @param sess 持久化操作所需要的Hiberate Session
     * @param pageNo 需要查询的指定页
     * @return 查询到的消息集合
     */
    List findAllByPage(Session sess , int pageNo , int pageSize);

    /** *//**
     * 查询消息的条数
     * @param sess 持久化操作所需要的Hiberate Session
     * @return 消息条数
     */
    long findCount(Session sess);
}

iii.实现DAO组件

Step:1.获取Hibernate Session；2.进行持久化操作；3.关闭Hibernate Session

package  org.prolove.dao.impl;

import  org.prolove.model. * ;
import  org.prolove.dao. * ;
import  org.hibernate.Session;

import  java.util. * ;
import  java.io.Serializable;

public   class  UserDaoHibernate  implements  UserDao
... {

    /** *//**
     * 根据主键加载用户
     * @param sess 持久化操作所需要的Hiberate Session
     * @param id 需要加载的用户ID
     * @return 加载的用户
     */
    public User get(Session sess, int id)
    ...{
        return (User)sess.load(User.class , id);
    }

    /** *//**
     * 保存用户
     * @param sess 持久化操作所需要的Hiberate Session
     * @param u 需要保存的用户
     * @return 保存用户的主键
     */
    public int save(Session sess, User u)
    ...{
        sess.save(u);
        return u.getId();
    }

    /** *//**
     * 删除用户
     * @param sess 持久化操作所需要的Hiberate Session
     * @param u 需要删除的用户
     */
    public void delete(Session sess, User u)
    ...{
        sess.delete(u);
    }

    /** *//**
     * 删除用户
     * @param sess 持久化操作所需要的Hiberate Session
     * @param id 需要删除的用户的id
     */
    public void delete(Session sess, int id)
    ...{
        sess.delete(get(sess, id));
    }

    /** *//**
     * 修改用户
     * @param sess 持久化操作所需要的Hiberate Session
     * @param u 需要修改的用户
     */
    public void update(Session sess, User u)
    ...{
        sess.saveOrUpdate(u);
    }

    /** *//**
     * 根据用户名查找用户
     * @param sess 持久化操作所需要的Hiberate Session
     * @param name 需要查找的用户的用户名
     * @return 查找到的用户
     */
    public User findByName(Session sess, String name)
    ...{
        List ul = sess.createQuery("from User as u where u.name = ?")
            .setParameter(0 , name)
            .list();
        if (ul != null && ul.size() > 0)
        ...{
            return (User)ul.get(0);
        }
        return null;
    }
}  

 

package  org.prolove.dao.impl;

import  org.prolove.model. * ;
import  org.prolove.dao. * ;
import  org.hibernate.Session;


import  java.io.Serializable;
import  java.util.List;

public   class  MessageDaoHibernate  implements  MessageDao
... {

    /** *//**
     * 根据主键加载消息
     * @param sess 持久化操作所需要的Hiberate Session
     * @param id 需要加载的消息ID
     * @return 加载的消息
     */
    public Message get(Session sess, int id)
    ...{
        return (Message)sess.load(Message.class , id);
    }

    /** *//**
     * 保存消息
     * @param sess 持久化操作所需要的Hiberate Session
     * @param m 需要保存的消息
     * @retun 保存消息的主键
     */
    public int save(Session sess, Message m)
    ...{
        sess.save(m);
        return m.getId();
    }

    /** *//**
     * 删除消息
     * @param sess 持久化操作所需要的Hiberate Session
     * @param m 需要删除的消息
     */
    public void delete(Session sess, Message m)
    ...{
        sess.delete(m);
    }

    /** *//**
     * 删除消息
     * @param sess 持久化操作所需要的Hiberate Session
     * @param id 需要删除的消息ID
     */
    public void delete(Session sess, int id)
    ...{
        sess.delete(get(sess , id));
    }

    /** *//**
     * 修改消息
     * @param sess 持久化操作所需要的Hiberate Session
     * @param m 需要修改的消息
     */
    public void update(Session sess, Message m)
    ...{
        sess.saveOrUpdate(m);
    }

    /** *//**
     * 查询指定用户、指定页的消息
     * @param sess 持久化操作所需要的Hiberate Session
     * @param pageNo 需要查询的指定页
     * @param pageSize 每页显示的消息数
     * @return 查询到的消息集合
     */
    public List findAllByPage(Session sess, int pageNo , int pageSize)
    ...{
        int offset = (pageNo - 1) * pageSize;
        return sess.createQuery("from Message m order by m.id desc")
            .setFirstResult(offset)
            .setMaxResults(pageSize)
            .list();
    }

    /** *//**
     * 查询消息的条数
     * @param sess 持久化操作所需要的Hiberate Session
     * @return 消息条数
     */
    public long findCount(Session sess)
    ...{
        Object obj = sess.createQuery("select count(m.id) from Message as m")
            .uniqueResult();
        //System.out.println(obj);
        return (Long)obj;
    }
}

iv.实现DAO工厂

配置文件-->daoContext.xml

 

 

<? xml version="1.0" encoding="GBK" ?>
< daoContext >
     < dao  id ="userDao"  class ="org.prolove.dao.impl.UserDaoHibernate" />
     < dao  id ="messageDao"  class ="org.prolove.dao.impl.MessageDaoHibernate" />
</ daoContext >

 

package  org.prolove.factory;

import  org.prolove.dao. * ;
import  org.prolove.dao.impl. * ;

import  org.dom4j. * ;
import  org.dom4j.io. * ;

import  java.util. * ;
import  java.io. * ;

public   class  DaoFactory
... {
    private Map<String , Object> daoMap = new HashMap<String , Object>(); 

    private static DaoFactory df;
    
    private DaoFactory(String path)throws Exception
    ...{
        Document doc = new SAXReader().read(new File(path + "/daoContext.xml"));
        Element root = doc.getRootElement();
        List el =  root.elements();
        for (Iterator it = el.iterator();it.hasNext() ; )
        ...{
            Element em = (Element)it.next();
            String id = em.attributeValue("id");
            String impl = em.attributeValue("class");
            Class implClazz = Class.forName(impl);
            Object obj = implClazz.newInstance();
            daoMap.put(id , obj);            
        }
    }

    public static DaoFactory instance(String path)throws Exception
    ...{
        if (df == null)
        ...{
            df = new DaoFactory(path); 
        }
        return df;
    }

    public Object getDao(String id)
    ...{
        return daoMap.get(id);
    }
}

五、业务逻辑层

i.业务逻辑组件的接口

package  org.prolove.service;

import  org.prolove.exception. * ;
import  org.prolove.vo. * ;

import  java.util.List;
import  javax.servlet.http.HttpServletRequest;

public   interface  MessageManager 
... {
    int MESSAGE_PAGE_SIZE = 3;
    /** *//**
     * 创建一条消息
     * @param title 新信息的标题
     * @param content 新消息的内容
     * @param userId 创建消息的用户Id
     * @return 新创建消息的主键,如果创建失败，返回-1。
     */
    int createMessage(String title , String content , int userId)
        throws MessageException;

    /** *//**
     * 创建一个用户
     * @param user 新创建用户的用户名
     * @param pass 新创建用户的密码
     * @return 新创建用户的主键
     */
    int createUser(String user , String pass)
        throws MessageException;

    /** *//**
     * 验证用户名是否可用,本系统不允许用户名重复
     * @param user 需要验证的用户名
     * @return 该用户名不重复，可用，返回true，否则返回false
     */
    boolean valid(String user)
        throws MessageException;

    /** *//**
     * 验证用户登录是否成功
     * @param user 登录所用的用户名
     * @param pass 登录所用的密码
     * @param session 登录后需将用户名存入session
     * @return 登录成功，返回用户的id，否则返回-1.
     */
    int login(String user , String pass)
        throws MessageException;

    /** *//**
     * 根据消息ID返回消息
     * @param id 消息ID
     * @return 指定ID对应的消息
     */
    MessageBean getMessage(int id)
        throws MessageException;

    /** *//**
     * 返回特定页面所有消息
     * @param pageNo 指定页码
     * @return 指定页的全部消息
     */
    List<MessageBean> getAllMessageByPage(int pageNo)
        throws MessageException;

    /** *//**
     * 获取消息数量
     * @return 消息的数量
     */
    int getMessageCount()throws MessageException;
    
    /** *//**
     * 根据每页记录数，总记录数获取总页数
     * @param count 总记录数
     * @param pageSize 每页显示的记录数
     * @return 计算得到的总页数
     */
    int getPageCount(int count , int pageSize);

}

ii.控制事务

本系统采用在业务逻辑方法中手动控制事务。

iii.实现业务逻辑组件

iv.业务逻辑组件与控制器的耦合

package  org.prolove.action.base;


import  org.prolove.service.MessageManager;
import  org.prolove.service.impl.MessageManagerImpl;

import  org.apache.struts.action.Action;

public   class  BaseAction  extends  Action
... {
    protected static MessageManager messManager;
    
    static 
    ...{
        try
        ...{
            messManager = new MessageManagerImpl();
        }
        catch (Exception e)
        ...{
            e.printStackTrace();
        }
    }

}

六、Web层设计

此处的Web层指的是系统中间层以上的部分，包括系统控制层以及对应的JSP页面。

i.实现系统的Listener

 

 

 

 

package  org.prolove.web;

import  javax.servlet. * ;
import  org.prolove.factory. * ;
import  org.hibernate.SessionFactory;

public   class  FactoryLoaderListener  implements  ServletContextListener
... { 
    DaoFactory df = null;
    SessionFactory sf = null;
    public void contextInitialized(ServletContextEvent sce)
    ...{
        try
        ...{
            sf = SessionFactoryBuilder.instance().getSessionFactory();
            System.out.println("Hibernate的SessionFactory已经被初始化... " + sf);    
        }
        catch (Exception e)
        ...{
            System.out.println("初始化SessionFactory工厂时出现异常" + e);
        }
        try
        ...{
            String path = sce.getServletContext().getRealPath("/WEB-INF/");
            df = DaoFactory.instance(path);
            System.out.println("DAO工厂已经被初始化... " + df);

        }
        catch (Exception e)
        ...{
            System.out.println("初始化DAO工厂时出现异常" + e);
        }
    } 
    
    public void contextDestroyed(ServletContextEvent sce)
    ...{
        sf = null;
        df = null;
    } 
}  

ii.使用Struts拦截所有请求

package  org.prolove.action.base;

import  org.apache.struts.action.ActionServlet;
import  javax.servlet.http.HttpServletRequest;
import  javax.servlet.http.HttpServletResponse;
  
public   class  MyActionServlet  extends  org.apache.struts.action.ActionServlet
... {
    protected void process(HttpServletRequest request, HttpServletResponse response)
        throws java.io.IOException, javax.servlet.ServletException
    ...{
        request.setCharacterEncoding("GBK");
        super.process(request, response);
    }
}

配置-->web.xml

 

 

 

 

 

<? xml version="1.0" encoding="GBK" ?>
< web-app  xmlns ="http://java.sun.com/xml/ns/j2ee"
    xmlns:xsi ="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation ="http://java.sun.com/xml/ns/j2ee http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd"
    version ="2.4" >

       < filter >
         < filter-name > loginFilter </ filter-name >
         < filter-class > org.prolove.web.UserLoginFilter </ filter-class >
         < init-param >
             < param-name > forwardpath </ param-name >
             < param-value > /index.jsp </ param-value >
         </ init-param >
     </ filter >
     < filter-mapping >
         < filter-name > loginFilter </ filter-name >
         < url-pattern > /* </ url-pattern >
     </ filter-mapping >

     < listener >  
         < listener-class > org.prolove.web.FactoryLoaderListener </ listener-class >  
     </ listener >  

     < servlet >
         < servlet-name > action </ servlet-name >
         < servlet-class > org.prolove.action.base.MyActionServlet </ servlet-class >
         < load-on-startup > 1 </ load-on-startup >
     </ servlet >
     < servlet-mapping >
         < servlet-name > action </ servlet-name >
         < url-pattern > *.do </ url-pattern >
     </ servlet-mapping >

</ web-app >

iii.完成用户登录

package  org.prolove.action;

import  org.apache.struts.action. * ;
import  org.apache.struts.validator.DynaValidatorForm;
import  javax.servlet.http. * ;

import  org.prolove.action.base.BaseAction;
import   static  org.prolove.util.AppConstants. * ;

public   class  ProcessLoginAction  extends  BaseAction
... {
    public ActionForward execute(ActionMapping mapping,ActionForm form,
        HttpServletRequest request, HttpServletResponse response)throws Exception
    ...{
        DynaValidatorForm loginForm = (DynaValidatorForm)form;
        String user = (String)loginForm.get("user");
        String pass = (String)loginForm.get("pass");
        int userId = messManager.login(user , pass);
        if (userId > 0)
        ...{
            request.getSession().setAttribute(LOGIN_USER , userId);
            return mapping.findForward("success");
        }
        request.setAttribute("msg" , "用户名和密码不匹配，请重试");
        return mapping.findForward("failure");
    
    }
}

统一给出配置文件：struts-config.xml

<? xml version="1.0" encoding="GBK" ?>
<! DOCTYPE struts-config PUBLIC
          "-//Apache Software Foundation//DTD Struts Configuration 1.2//EN"
          "http://struts.apache.org/dtds/struts-config_1_2.dtd" >
< struts-config >
     < form-beans >
         < form-bean  name ="loginForm"  type ="org.apache.struts.validator.DynaValidatorForm" >
               < form-property  name ="user"  type ="java.lang.String" />
               < form-property  name ="pass"  type ="java.lang.String" />
         </ form-bean >

         < form-bean  name ="postMessageForm"  type ="org.apache.struts.validator.DynaValidatorForm" >
               < form-property  name ="title"  type ="java.lang.String" />
               < form-property  name ="content"  type ="java.lang.String" />
         </ form-bean >

         < form-bean  name ="registForm"  type ="org.apache.struts.validator.DynaValidatorForm" >
               < form-property  name ="user"  type ="java.lang.String" />
               < form-property  name ="pass"  type ="java.lang.String" />
         </ form-bean >

     </ form-beans >    


     < global-exceptions >
             < exception  key ="MessageException"   
                       type ="org.yeeku.exception.MessageException"
                       scope ="request"
                       path ="/WEB-INF/jsp/error.jsp" />     
     </ global-exceptions >

     < action-mappings >
         < action  path ="/enterPostMessage"  forward ="/WEB-INF/jsp/postMessage.jsp" />
         < action  path ="/enterRegist"  forward ="/WEB-INF/jsp/regist.jsp" />


         <!--  处理用户登录  -->
         < action  path ="/processLogin"  name ="loginForm"  type ="org.prolove.action.ProcessLoginAction"
            scope ="request"  validate ="true"  input ="/WEB-INF/jsp/login.jsp" >
             < forward  name ="success"  path ="/listMessage.do"   />
             < forward  name ="failure"  path ="/WEB-INF/jsp/login.jsp"   />
         </ action >
         <!--  处理用户注册  -->
         < action  path ="/processRegist"  name ="registForm"  type ="org.prolove.action.ProcessRegistAction"
            scope ="request"  validate ="true"  input ="/WEB-INF/jsp/login.jsp" >
             < forward  name ="success"  path ="/WEB-INF/jsp/login.jsp"   />
             < forward  name ="failure"  path ="/WEB-INF/jsp/regist.jsp"   />

         </ action >

         <!--  列出所有消息  -->
         < action  path ="/listMessage"   type ="org.prolove.action.ListMessageAction"
            scope ="request" >
             < forward  name ="success"  path ="/WEB-INF/jsp/listMessage.jsp"   />
         </ action >

         <!--  处理添加消息  -->
         < action  path ="/processPostMessage"  name ="postMessageForm"  type ="org.prolove.action.ProcessPostMessageAction"
            scope ="request"  validate ="true"  input ="/WEB-INF/jsp/postMessage.jsp" >
             < forward  name ="success"  path ="/listMessage.do"   />
         </ action >

         <!--  处理查看消息  -->
         < action  path ="/viewMessage"  type ="org.prolove.action.ViewMessageAction"
            scope ="request" >
             < forward  name ="success"  path ="/WEB-INF/jsp/viewMessage.jsp"   />
         </ action >

     </ action-mappings >

     < message-resources   parameter ="message" />

     < plug-in  className ="org.apache.struts.validator.ValidatorPlugIn" >
         < set-property  property ="pathnames"  value ="/WEB-INF/validator-rules.xml,/WEB-INF/validation.xml"   />
         < set-property  property ="stopOnFirstError"  value ="true"   />
     </ plug-in >

</ struts-config >

iv.列出留言列表

package  org.prolove.action;

import  org.apache.struts.action. * ;
import  org.apache.struts.validator.DynaValidatorForm;
import  javax.servlet.http. * ;

import  org.prolove.service.MessageManager;
import  org.prolove.action.base.BaseAction;

public   class  ListMessageAction  extends  BaseAction
... {
    public ActionForward execute(ActionMapping mapping,ActionForm form,
        HttpServletRequest request, HttpServletResponse response)throws Exception
    ...{
        int messageCount = messManager.getMessageCount();

        //获取总页数
        int pageCount = messManager.getPageCount(messageCount , MessageManager.MESSAGE_PAGE_SIZE);

        int pageNo;
        String pageNoStr = request.getParameter("pageNo");
        if (pageNoStr == null || pageNoStr.trim().equals(""))
        ...{
            pageNo = 1;
        }
        try
        ...{
            pageNo = Integer.parseInt(pageNoStr.trim());
        }
        catch (Exception e)
        ...{
            pageNo = 1;
        }
        //如果请求页已经超出了最大页
        if (pageNo > pageCount)
        ...{
            pageNo = pageCount;
        }
        request.setAttribute("pageCount" , pageCount);
        request.setAttribute("currentPage" , pageNo);
        request.setAttribute("messageList" , messManager.getAllMessageByPage(pageNo));
        return mapping.findForward("success");

    
    }
}

JSP页面中输出Request中List属性-->listMessage.jsp

<% ... @ page contentType="text/html; charset=GBK" language="java" errorPage="exception.jsp" %>
<% ... @include file="taglibs.jsp" %>
< html  xmlns ="http://www.w3.org/1999/xhtml" >
< head >
< title > 列出所有留言 </ title >
< link  href ="img/css.css"  rel ="stylesheet"  type ="text/css" >

</ head >

< body >
< div  align ="center" >
< div  class ="dojoDialog"  style ="width:600px;" >
< table  border ="1"  align ="center"  width ="600"  style ="border-collapse:collapse;font-size:10pt"   >
   < caption >
    电子留言系统
   </ caption >
   < tr >
     < td  colspan ="2"  align ="right" >< a  href ="enterPostMessage.do" >  发表新留言 </ a ></ td >
   </ tr >
   < tr >
     < th  width ="120" > 作者 </ th >
     < th  width ="480"   > 留言标题 </ th >
   </ tr >
< logic:present  name ="messageList"  scope ="request"   >
< logic:iterate  id ="message"  name ="messageList"  type ="org.yeeku.vo.MessageBean"  scope ="request"   >
     < tr >
       < td  align ="center"  width ="167" >< bean:write  name ="message"  property ="owerName" /></ td >
       < td  align ="center" >< a  href ='viewMessage.do?messageId=<bean:write  name ="message"  property ="id" /> '> < bean:write  name ="message"  property ="title" /></ a ></ td >
     </ tr >
</ logic:iterate >
   < tr >
     < td  align ="right"  colspan ="2" >
        第${requestScope.currentPage}页 &nbsp;
        共${requestScope.pageCount}页 &nbsp;
         < a  href ="listMessage.do?pageNo=1" > 首页 </ a >
         < logic:greaterThan  name ="currentPage"  value ="1"  scope ="request" >< a  href ="listMessage.do?pageNo=${requestScope.currentPage - 1}" ></ logic:greaterThan >
        上一页
         < logic:greaterThan  name ="currentPage"  value ="1"  scope ="request" ></ a ></ logic:greaterThan >
         < logic:lessThan  name ="currentPage"  value ='${requestScope.pageCount}'  scope ="request" >< a  href ="listMessage.do?pageNo=${requestScope.currentPage + 1}" ></ logic:lessThan >
        下一页 < logic:lessThan  name ="currentPage"  value ='${requestScope.pageCount}'  scope ="request" ></ a ></ logic:lessThan >
         < a  href ="listMessage.do?pageNo=${requestScope.pageCount}" > 尾页 </ a >
   </ td >
   </ tr >
</ logic:present >
< logic:notPresent  name ="messageList"  scope ="request"   >
   < tr >
     < td  align ="center"  colspan ="2" > 暂时没有任何留言 </ td >
   </ tr >
</ logic:notPresent >
</ table >
</ div >
</ div >
  <% ... @include file="copyright.jsp" %>
</ body >
</ html >

v.查看留言

package  org.prolove.action;

import  org.apache.struts.action. * ;
import  org.apache.struts.validator.DynaValidatorForm;
import  javax.servlet.http. * ;

import  org.prolove.service.MessageManager;
import  org.prolove.action.base.BaseAction;
import  org.prolove.exception.MessageException;

public   class  ViewMessageAction  extends  BaseAction
... {
    public ActionForward execute(ActionMapping mapping,ActionForm form,
        HttpServletRequest request, HttpServletResponse response)throws Exception
    ...{
        String idStr = request.getParameter("messageId");
        int messageId = 0;
        if (idStr == null || idStr.trim().equals(""))
        ...{
            throw new MessageException(" 需要查看的留言ID丢失");
        }
        try
        ...{
            messageId = Integer.parseInt(idStr.trim());
        }
        catch (Exception e)
        ...{
            throw new MessageException("非法的留言ID");
        }
        request.setAttribute("viewing" , messManager.getMessage(messageId));
        return mapping.findForward("success");

    
    }
}

 

<% ... @ page contentType="text/html; charset=GBK" language="java" errorPage="exception.jsp" %><% ... @include file="taglibs.jsp" %>
<! DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd" >
< html  xmlns ="http://www.w3.org/1999/xhtml" >
< head >
< meta  http-equiv ="Content-Type"  content ="text/html; charset=GBK"   />
< title > 查看留言 </ title >
< link  href ="img/css.css"  rel ="stylesheet"  type ="text/css" >
</ head >
< body >
< div  align ="center" >
< div  class ="dojoDialog"  style ="width:600px;" >
     < table >
         < caption > 查看留言 </ caption >
             < tr >
                 < td > 标题： </ td >
                 < td > ${requestScope.viewing.title} </ td >
             </ tr >
             < tr >
                 < td > 发布者： </ td >
                 < td > ${requestScope.viewing.owerName} </ td >
             </ tr >
             < tr >
                 < td > 内容： </ td >
                 < td >< textarea  cols ="50"  rows ="8"  disabled > ${requestScope.viewing.content} </ textarea ></ td >
             </ tr >
             < tr >
                 < td  colspan ="2"  align ="center" >
                     < a  href ="listMessage.do" > 返回 </ a >
                 </ td >
             </ tr >
     </ table >
</ div >
</ div >
  <% ... @include file="copyright.jsp" %>
</ body >
</ html >

vi.数据校验的处理

-->validation.xml

<? xml version="1.0" encoding="iso-8859-1" ?>
<! DOCTYPE form-validation PUBLIC
          "-//Apache Software Foundation//DTD Commons Validator Rules Configuration 1.1.3//EN"
          "http://jakarta.apache.org/commons/dtds/validator_1_1_3.dtd" >

< form-validation >
     < formset >
         < form  name ="loginForm" >
             < field  property ="user"  depends ="required,minlength" >
                 < arg  key ="loginForm.user"  position ="0" />
                 < arg  name ="minlength"  key ="${var:minlength}"  resource ="false"  position ="1" />
                 < var >
                     < var-name > minlength </ var-name >
                     < var-value > 3 </ var-value >
                 </ var >
             </ field >
             < field  property ="pass"  depends ="required,minlength" >
                 < arg  key ="loginForm.pass"  position ="0" />
                 < arg  name ="minlength"  key ="${var:minlength}"  resource ="false"  position ="1" />
                 < var >
                     < var-name > minlength </ var-name >
                     < var-value > 3 </ var-value >
                 </ var >
             </ field >
         </ form >

         < form  name ="postMessageForm" >
             < field  property ="title"  depends ="required,minlength" >
                 < arg  key ="postMessageForm.title"  position ="0" />
                 < arg  name ="minlength"  key ="${var:minlength}"  resource ="false"  position ="1" />
                 < var >
                     < var-name > minlength </ var-name >
                     < var-value > 3 </ var-value >
                 </ var >
             </ field >
             < field  property ="content"  depends ="required,minlength" >
                 < arg  key ="postMessageForm.content"  position ="0" />
                 < arg  name ="minlength"  key ="${var:minlength}"  resource ="false"  position ="1" />
                 < var >
                     < var-name > minlength </ var-name >
                     < var-value > 10 </ var-value >
                 </ var >
             </ field >
         </ form >

         < form  name ="registForm" >
             < field  property ="user"  depends ="required,minlength" >
                 < arg  key ="registForm.title"  position ="0" />
                 < arg  name ="minlength"  key ="${var:minlength}"  resource ="false"  position ="1" />
                 < var >
                     < var-name > minlength </ var-name >
                     < var-value > 3 </ var-value >
                 </ var >
             </ field >
             < field  property ="pass"  depends ="required,minlength" >
                 < arg  key ="registForm.content"  position ="0" />
                 < arg  name ="minlength"  key ="${var:minlength}"  resource ="false"  position ="1" />
                 < var >
                     < var-name > minlength </ var-name >
                     < var-value > 3 </ var-value >
                 </ var >
             </ field >
         </ form >

     </ formset >
</ form-validation >

vii.权限管理

package  org.prolove.web;

import  java.io.IOException;

import  javax.servlet.Filter;
import  javax.servlet.FilterChain;
import  javax.servlet.FilterConfig;
import  javax.servlet.ServletException;
import  javax.servlet.ServletRequest;
import  javax.servlet.ServletResponse;
import  javax.servlet.http.HttpServletRequest;
import  javax.servlet.http.HttpServletResponse;
import  javax.servlet.http.HttpSession;

import   static  org.prolove.util.AppConstants. * ;

/** */ /**
 * 过滤未登录的非法请求
 */
public   class  UserLoginFilter  implements  Filter
... {

    private String forwardPath = null;
    private FilterConfig filterConfig = null;

    public void destroy()
    ...{
        this.forwardPath = null;
        this.filterConfig = null;
    }

    public void doFilter(ServletRequest request, ServletResponse response,
            FilterChain chain) throws IOException, ServletException
    ...{

        HttpServletRequest httpServletRequest = (HttpServletRequest) request;
        HttpServletResponse httpServletResponse = (HttpServletResponse) response;
        String requesturi = httpServletRequest.getRequestURI();
        // 通过检查session中的变量，过滤请求
        HttpSession session = httpServletRequest.getSession();
        Object currentUser = session.getAttribute(LOGIN_USER);
        // 当前会话用户为空而且不是请求登录，退出登录，欢迎页面和根目录则退回到应用的根目录
        if (currentUser == null
                && !requesturi.endsWith("/enterRegist.do")
                && !requesturi.endsWith("/processRegist.do")
                && !requesturi.endsWith("/processLogin.do")
                && !requesturi.endsWith("login.jsp")
                && !requesturi.endsWith("css")
                && !requesturi.endsWith(httpServletRequest.getContextPath()
                        + "/"))
        ...{
            System.out.println("Filter启动了作用....");
            httpServletResponse.sendRedirect(httpServletRequest
                    .getContextPath()
                    + "/");
            return;
        }
        chain.doFilter(request, response);
    }

    public void init(FilterConfig filterConfig) throws ServletException
    ...{
        this.filterConfig = filterConfig;
        this.forwardPath = filterConfig.getInitParameter("forwardpath");
    }
}

 

package  org.prolove.util;

public   interface  AppConstants
... {
    String LOGIN_USER = "user";
}

 

 

 

package  org.prolove.service.impl;

import  org.prolove.dao. * ;
import  org.prolove.model. * ;
import  org.prolove.exception. * ;
import  org.prolove.service. * ;
import  org.prolove.vo. * ;
import  org.prolove.factory. * ;

import  java.util.List;
import  java.util.ArrayList;
import  org.hibernate. * ;

public   class  MessageManagerImpl  implements  MessageManager
... {
    private UserDao userDao;
    private MessageDao messDao;

    public MessageManagerImpl()throws MessageException
    ...{
        try
        ...{
            userDao = (UserDao)DaoFactory.instance(null).getDao("userDao");
            messDao = (MessageDao)DaoFactory.instance(null).getDao("messageDao");            
        }
        catch (Exception e)
        ...{
            e.printStackTrace();
            throw new MessageException("初始化业务逻辑组件出现异常...");
        }

    }


    /** *//**
     * 创建一条消息
     * @param title 新信息的标题
     * @param content 新消息的内容
     * @param userId 创建消息的用户Id
     * @return 新创建消息的主键,如果创建失败，返回-1。
     */
    public int createMessage(String title , String content , int userId)
        throws MessageException
    ...{
        Session sess = null;
        Transaction tx = null;
        try
        ...{
            sess = SessionFactoryBuilder.instance().getSessionFactory().openSession();
            tx = sess.beginTransaction();
            User u = userDao.get(sess , userId);
            if ( u != null)
            ...{
                Message m = new Message();
                m.setTitle(title);
                m.setContent(content);
                m.setUser(u);
                messDao.save(sess , m);
                tx.commit();
                return m.getId();
            }
            tx.commit();
            return -1;
        }
        catch (Exception e)
        ...{
            tx.rollback();
            e.printStackTrace();
            throw new MessageException("添加消息出现异常");
        }
        finally
        ...{
            sess.close();
        }
    }

    /** *//**
     * 创建一个用户
     * @param user 新创建用户的用户名
     * @param pass 新创建用户的密码
     * @return 新创建用户的主键
     */
    public int createUser(String user , String pass)
        throws MessageException
    ...{
        Session sess = null;
        Transaction tx = null;
        try
        ...{
            sess = SessionFactoryBuilder.instance().getSessionFactory().openSession();
            tx = sess.beginTransaction();

            if (userDao.findByName(sess , user) != null)
                throw new MessageException("该用户名已经存在");
            User u = new User();
            u.setName(user);
            u.setPass(pass);
            userDao.save(sess, u);
            tx.commit();
            return u.getId();
        }
        catch (Exception e)
        ...{
            tx.rollback();
            e.printStackTrace();
            throw new MessageException("注册用户出现异常");
        }
        finally
        ...{
            sess.close();
        }
    }

    /** *//**
     * 验证用户名是否可用,本系统不允许用户名重复
     * @param user 需要验证的用户名
     * @return 该用户名不重复，可用，返回true，否则返回false
     */
    public boolean valid(String user)
        throws MessageException
    ...{
        Session sess = null;
        Transaction tx = null;
        try
        ...{
            sess = SessionFactoryBuilder.instance().getSessionFactory().openSession();
            tx = sess.beginTransaction();
            if (userDao.findByName(sess, user) == null)
            ...{
                tx.commit();
                return true;
            }
            tx.commit();
            return false;
        }
        catch (Exception e)
        ...{
            tx.rollback();
            e.printStackTrace();
            throw new MessageException("验证用户名出现异常");
        }
        finally
        ...{
            sess.close();
        }
    }

    /** *//**
     * 验证用户登录是否成功
     * @param user 登录所用的用户名
     * @param pass 登录所用的密码
     * @return 登录成功，返回用户的id，否则返回-1.
     */
    public int login(String user , String pass)
        throws MessageException
    ...{
        Session sess = null;
        Transaction tx = null;
        try
        ...{
            sess = SessionFactoryBuilder.instance().getSessionFactory().openSession();
            tx = sess.beginTransaction();
            User u = userDao.findByName(sess , user);
            if (u != null && u.getPass().equals(pass))
            ...{
                tx.commit();
                return u.getId();
            }
            tx.commit();
            return -1;

        }
        catch (Exception e)
        ...{
            tx.rollback();
            e.printStackTrace();
            throw new MessageException("处理登录出现异常");
        }
        finally
        ...{
            sess.close();
        }
    }


    /** *//**
     * 根据消息ID返回消息
     * @param id 消息ID
     * @return 指定ID对应的消息
     */
    public MessageBean getMessage(int id)
        throws MessageException
    ...{
        Session sess = null;
        Transaction tx = null;
        try
        ...{
            sess = SessionFactoryBuilder.instance().getSessionFactory().openSession();
            tx = sess.beginTransaction();
            Message m = messDao.get(sess , id);
            if (m != null)
            ...{
                tx.commit();
                return new MessageBean(0 , m.getTitle() , m.getContent() , m.getUser().getId() , m.getUser().getName());
            }
            tx.commit();
            return null;

        }
        catch (Exception e)
        ...{
            tx.rollback();
            e.printStackTrace();
            throw new MessageException("获取消息内容出现异常");
        }
        finally
        ...{
            sess.close();
        }
    }

    /** *//**
     * 返回特定页面所有消息
     * @param pageNo 指定页码
     * @return 指定页的全部消息
     */
    public List<MessageBean> getAllMessageByPage(int pageNo)
        throws MessageException
    ...{
        Session sess = null;
        Transaction tx = null;
        try
        ...{
            sess = SessionFactoryBuilder.instance().getSessionFactory().openSession();
            tx = sess.beginTransaction();

            List ml = messDao.findAllByPage(sess , pageNo , MESSAGE_PAGE_SIZE);
            if (ml != null && ml.size() > 0)
            ...{
                List<MessageBean> result = new ArrayList<MessageBean>();
                for (Object obj : ml)
                ...{
                    Message me = (Message)obj;
                    result.add(new MessageBean(me.getId() , me.getTitle(), null , 0 , me.getUser().getName()));
                }
                tx.commit();
                return result;
            }
            tx.commit();
            return null;
        }
        catch (Exception e)
        ...{
            tx.rollback();
            e.printStackTrace();
            throw new MessageException("获取消息内容出现异常");
        }
        finally
        ...{
            sess.close();
        }
    }

    /** *//**
     * 获取消息数量
     * @return 消息的数量
     */
    public int getMessageCount()throws MessageException
    ...{
        Session sess = null;
        Transaction tx = null;
        try
        ...{
            sess = SessionFactoryBuilder.instance().getSessionFactory().openSession();
            tx = sess.beginTransaction();
            int result = (int)messDao.findCount(sess);
            tx.commit();
            return result;
        }
        catch (Exception e)
        ...{
            tx.rollback();
            throw new MessageException("获取试题数量时出现异常,请重试！");
        }
        finally
        ...{
            sess.close();
        }
    }

    /** *//**
     * 根据每页记录数，总记录数获取总页数
     * @param count 总记录数
     * @param pageSize 每页显示的记录数
     * @return 计算得到的总页数
     */
    public int getPageCount(int count , int pageSize)
    ...{
        return (count + pageSize - 1 ) / pageSize;
    }
}