public class XmlToSql
{
 public static void getNode(NodeList nl,StringBuffer sql)
 {
  for(int i=0;i<nl.getLength();i++)
  {
   Node node = nl.item(i);
   if(node.getNodeType() == Node.ELEMENT_NODE)
   {
    if(node.hasAttributes())
    {
     sql.append(node.getNodeName()+" ");
     NamedNodeMap attr = node.getAttributes();
     sql.append(attr.getNamedItem("Type").getNodeValue());
     if(attr.getNamedItem("Length")!=null)
     {
      sql.append("("+attr.getNamedItem("Length").getNodeValue()+")");
     }    
     sql.append(",");
     if(attr.getNamedItem("Index")!=null && attr.getNamedItem("Index").getNodeValue().equals("True"))
     {
      sql.append("index index_"+node.getNodeName()+"("+node.getNodeName()+"),");
     }
    }
    else
    {
     getNode(node.getChildNodes(),sql);
    }       
   }
  }
 }
 
 public static void main(String[] args)
 {
  try
  {
   DocumentBuilderFactory fac = DocumentBuilderFactory.newInstance();
   DocumentBuilder builder = fac.newDocumentBuilder();
   Document document = builder.parse(new File("Data.xml"));
   
   Node node = document.getFirstChild();
   
   StringBuffer sql = new StringBuffer("create table temp(id int(11) NOT NULL auto_increment,");
   getNode(node.getChildNodes(),sql);
   sql.append("PRIMARY KEY  (id))");
   
   Class.forName("com.mysql.jdbc.Driver");
   String url ="jdbc:mysql://localhost/test";
   Connection conn= DriverManager.getConnection(url,"root","root");
   Statement stmt = conn.createStatement();
   stmt.execute(sql.toString());
  }
  catch(Exception e){
   e.printStackTrace();
  }
 } 
}

//get & set
}

public class Department //专业
{
 private Integer id;
 private Institute institute;//学院属性
 private String department;

   //get & set
}

下面就是配置文件了：

<hibernate-mapping>

 <class name="subject.model.Institute">
      <id name="id">
         <generator class="increment"/>
       </id>

      <property name="institute"/>
 </class>

<class name="subject.model.Department">
      <id name="id">
         <generator class="increment" />
      </id>

      <property name="department" />
      
      <many-to-one name="institute" class="subject.model.Institute" 
          column="instituteId" lazy="false"/>//多对一，lazy="false"来将依赖延迟设置为false
   </class>
 
</hibernate-mapping>

所谓依赖延迟就是说，如果我们把他设置为true，那么我们得到的department中的该属性初始化为空，否则就有该属性了！

2.继承

在我的系统中，存在三种用户，管理员、学生、教师，他们都有综合的属性，也有个性的地方，具体的类介绍如下：

public abstract class User //父类用户
{
 private Integer id;
 private String user;
 private String password;
 private String name;
 private String telphone;
 //get & set
}

public class Student extends User//学生
{
 private SchoolClass schoolClass;
 private String sn;
}

public class Teacher extends User//教师
{
 private String level;
 private Boolean confirm;
}

public class Admin extends User//管理员
{
 private String grade;
}

在数据库中我把三种角色的对象存放在一个表中，用一个字段来区分三种角色，在hibernate映射继承时属于一种情况，可以参照书中的介绍：

<hibernate-mapping>

 <class name="subject.model.User" discriminator-value="not null"> //这里的not null很关键，没这个就会出现问题

  <id name="id">
   <generator class="increment" />
  </id>
  
  <discriminator column="type" type="character" />
  
  <property name="user" />
  <property name="password" />
  <property name="name" />
  <property name="telphone" />

  <subclass name="subject.model.Admin" discriminator-value="a">//存储对象类型的标识符
   <property name="grade" column="sn" />//对于每种对象的字段都放到数据库的一列里了
  </subclass>
  
  <subclass name="subject.model.Teacher" discriminator-value="t">
   <property name="level" column="sn" />
   <property name="confirm" column="about" />
  </subclass>
  
  <subclass name="subject.model.Student" discriminator-value="s">
   
   <property name="sn" />
   
   <many-to-one name="schoolClass" class="subject.model.SchoolClass"
    column="about" lazy="false"/>
    
  </subclass>

 </class>

</hibernate-mapping>

package subject.bean;

import java.util.ArrayList;
import java.util.List;

public class Page
{
 private int current = 1; //当前页码
 private int nextPage = 0; //下一页码
 private int previousPage = 0;//上一页码
 private int total = 0;//总的数据
 private int pages = 0;//总页数
 private int each = 5;//每页数据
 private int start = 0;//当前页的起始数据
 private int end = 0;//当前页的结束数据
 private boolean next = false;//是否存在下一页
 private boolean previous = false;//是否存在上一页
 private List list = null; //需要显示的数据

 public Page( List list, int each )//以需要显示的数据和每页要显示的数据为参数进行初始化
 {
  this.list = list;
  this.each = each;
  total = list.size();//总的数据等于List的大小
  if ( total % each == 0 )//总页数和没页显示的数据可以整除，则为总页数
   pages = total / each;
  else
   pages = total / each + 1;//否则就需要加上一页了
  if ( current >= pages )
  {
   next = false;//判断是否有下一页
  }
  else
  {
   next = true;
   nextPage = current + 1;//有，还得算出来下一页是多少呢！
  }
  if ( total < each )
  {
   start = 0;//这页显示多少数据啊？如果是最后一页，只显示整除后的余数了
   end = total;
  }
  else
  {
   start = 0;//否则要显示每页需要显示的数据数
   end = each;
  }
 }

 public int getCurrent()
 {
  return current;
 }

 public boolean isNext()
 {
  return next;
 }

 public boolean isPrevious()
 {
  return previous;
 }

 public int getPages()
 {
  return pages;
 }

 public int getTotal()
 {
  return total;
 }

 public int getNextPage()
 {
  return nextPage;
 }

 public int getPreviousPage()
 {
  return previousPage;
 }

 @SuppressWarnings ( "unchecked" )
 public List get( int page )//获取指定页码的List
 {
  if ( page > 0 && page <= pages )
  {
   current = page;//page在有效范围内则为当前页
  }
  if ( ( current - 1 ) > 0 )//计算上一页是否存在以及值
  {
   previous = true;
   previousPage = current - 1;
  }
  else
  {
   previous = false;
  }
  if ( current >= pages )//计算下一页是否存在以及值
  {
   next = false;
  }
  else
  {
   next = true;
   nextPage = current + 1;
  }
  if ( page * each < total )//计算显示的记录在List中的位置
  {
   end = current * each;
   start = end - each;
  }
  else
  {
   end = total;
   start = each * ( pages - 1 );
  }
  List gets = new ArrayList();//把显示的数据放到一个新的List里
  for ( int i = start; i < end; i++ )
  {
   gets.add( list.get( i ) );
  }
  return gets;
 }
}

上面的Page Bean比那个就简略的很多，我们再来看看Action怎么来做？

public class AdminAction extends BaseAction
{
 private AdminManager mgr;

 public void setAdminManager( AdminManager mgr )
 {
  this.mgr = mgr;
 }

public ActionForward execute( ActionMapping mapping, ActionForm form,
   HttpServletRequest request, HttpServletResponse response )
   throws Exception
 {
  Integer pageId = getInt( request, "page" );
  Page page = null;
  List rs =mgr.getStudents();
   if ( rs != null && rs.size() != 0 )
   {
    page = new Page( rs, 10 );
    request.setAttribute( "students", page.get( pageId ) );
   }
   request.setAttribute( "search", Select.studentSearch() );
  }  
  request.setAttribute( "page", page );
  return mapping.findForward("student");
 }

}

这样我们就可以把分页对象和List放到Execute中了，在这里我们把业务逻辑对象AdminManager的实例mgr声明成了bean的形式，这样可以在Spring中利用ioc来注入：

Struts的声明：

<action path="/admin" type="org.springframework.web.struts.DelegatingActionProxy" />

Spring中的声明：

<!-- 业务逻辑 -->
 <bean id="txProxyTemplate" abstract="true" class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean">
  <property name="transactionManager" ref="transactionManager" />
  <property name="transactionAttributes">
   <props>
    <prop key="save*">PROPAGATION_REQUIRED</prop>
    <prop key="remove*">PROPAGATION_REQUIRED</prop>
    <prop key="get*">PROPAGATION_REQUIRED,readOnly</prop>
   </props>
  </property>
 </bean>

 <bean id="adminManager" parent="txProxyTemplate">
  <property name="target">
   <bean class="subject.service.impl.AdminManagerImpl">
    <property name="dao" ref="dao" />
   </bean>
  </property>
 </bean>

<bean name="/admin/admin" class="subject.web.action.AdminAction" singleton="false">
  <property name="adminManager">
   <ref bean="adminManager" />
  </property>
 </bean>

从而实现了Struts和Spring的完美暇接，singleton="false"从而可以解决单例的诟病！

在model里,我们采用了继承关系:

父类user:
package subject.model;

public abstract class User extends BaseObject
{
 private Integer id;
 private String user;
 private String password;
 private String name;
 private String telphone;

//set and get method 
 
 public abstract String getType(); //这个是用来反映用户角色的关键函数,在子类实现,从而实现多态
}

子类的实现:
======================
package subject.model;

import subject.Constants;

public class Teacher extends User
{
 private String level;         //教师的职称

//set and get method

 public String getType()
 {
  return Constants.TEACHER;
 }
}
================
package subject.model;

import subject.Constants;

public class Student extends User
{
 private static final long serialVersionUID = 1L;

 private SchoolClass schoolClass;         //学生的班级
 private String sn;             //学生的学号

//set and get method
 
 public String getType()
 {
  return Constants.STUDENT;
 }
}
=================
package subject.model;

import subject.Constants;

public class Admin extends User
{
 private String grade;           //管理员的级别
//set and get method

 public String getType()
 {
  return Constants.ADMIN;
 }
}

对于三者所共有的属性在数据库里,都存在一个字段,而依据不同的角色拥有不同的含义,学生的班级则存放在了about里,只要学生有班级,他就able,否则就enable了!而管理员和教师则默认为1!

这种是属于一个继承树存放在一个表的情况,Hibernate的配置如下:
<hibernate-mapping>

 <class name="subject.model.User" discriminator-value="not null">

  <id name="id">
   <generator class="increment" />
  </id>
  
  <discriminator column="type" type="character" />
  
  <property name="user" />
  <property name="password" />
  <property name="name" />
  <property name="telphone" />

  <subclass name="subject.model.Admin" discriminator-value="a">
   <property name="grade" column="sn" />
  </subclass>
  
  <subclass name="subject.model.Teacher" discriminator-value="t">
   <property name="level" column="sn" />
  </subclass>
  
  <subclass name="subject.model.Student" discriminator-value="s">
   
   <property name="sn" />
   
   <many-to-one name="schoolClass" class="subject.model.SchoolClass"
    column="about" update="false" insert="false" />
    
  </subclass>

 </class>

</hibernate-mapping>

=============================================
上面的这些都是模型的基础,下面再讲怎么样配合Spring和Acegi实现系统的安全与登陆
在Spring中Hibernate的配置只介绍不说明:
<!-- 定义DBCP数据源 -->
 <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">
  <property name="driverClassName" value="com.mysql.jdbc.Driver" />
  <property name="url" value="jdbc:mysql://localhost/subject?useUnicode=true&amp;characterEncoding=gbk" />
  <property name="username" value="root" />
  <property name="password" value="" />
  <property name="maxActive" value="100" />
  <property name="maxIdle" value="30" />
  <property name="maxWait" value="1000" />
  <property name="defaultAutoCommit" value="true" />
  <property name="removeAbandoned" value="true" />
  <property name="removeAbandonedTimeout" value="60" />
 </bean>

 <!-- Hibernate -->
 <bean id="sessionFactory" class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
  <property name="dataSource" ref="dataSource" />
  <property name="mappingResources">
   <list>
    <value>subject/model/User.hbm.xml</value>
   </list>
  </property>
  <property name="hibernateProperties">
   <props>
    <prop key="hibernate.dialect">org.hibernate.dialect.MySQLInnoDBDialect</prop>
   </props>
  </property>
 </bean>

 <bean id="transactionManager" class="org.springframework.orm.hibernate3.HibernateTransactionManager">
  <property name="sessionFactory" ref="sessionFactory" />
 </bean>

<!-- Dao对象 -->
<bean id="userDao" class="subject.dao.hibernate.UserDaoImpl">
  <property name="sessionFactory" ref="sessionFactory" />
 </bean>

<!-- 业务逻辑 -->
 <bean id="txProxyTemplate" abstract="true" class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean">
  <property name="transactionManager" ref="transactionManager" />
  <property name="transactionAttributes">
   <props>
    <prop key="save*">PROPAGATION_REQUIRED</prop>
    <prop key="remove*">PROPAGATION_REQUIRED</prop>
    <prop key="get*">PROPAGATION_REQUIRED,readOnly</prop>
   </props>
  </property>
 </bean>

<bean id="userManager" parent="txProxyTemplate">
  <property name="target">
   <bean class="subject.service.impl.UserManagerImpl">
    <property name="userDao" ref="userDao" />
   </bean>
  </property>
 </bean>

<!-- Struts -->
 <bean name="/user" class="subject.web.action.UserAction" singleton="false">
  <property name="userManager">
   <ref bean="userManager" />
  </property>
 </bean>
==================
上面具体的不用了解,无非就是调用和数据库的操作,
下面就要对Acegi进行声明了:
我不用Ctrl+c和Ctrl+V的方式对Acegi进行介绍,没有意义,随便google就一大堆
我们想主要在这样的系统中需要的安全策略都有哪些?
1.用户的登陆
2.防止多个用户登陆一个帐号
3.用户的注销
4.防止非法用户的访问

我这个程序所涉及到的只有这些,下面就进行说明:

在web.xml的声明:
<!-- Acegi安全控制 Filter 配置 -->
    <filter>
        <filter-name>securityFilter</filter-name>
        <filter-class>org.acegisecurity.util.FilterToBeanProxy</filter-class>
        <init-param>
            <param-name>targetClass</param-name>
            <param-value>org.acegisecurity.util.FilterChainProxy</param-value>
        </init-param>
    </filter>
   
    <filter-mapping>
        <filter-name>securityFilter</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>

Acegi通过实现了Filter接口的FilterToBeanProxy提供一种特殊的使用Servlet Filter的方式，它委托Spring中的Bean -- FilterChainProxy来完成过滤功能，这样就简化了web.xml的配置，并且利用Spring IOC的优势。FilterChainProxy包含了处理认证过程的filter列表，每个filter都有各自的功能。

<!-- ======================== FILTER CHAIN ======================= -->
 <bean id="filterChainProxy" class="org.acegisecurity.util.FilterChainProxy">
  <property name="filterInvocationDefinitionSource">
   <value>
    CONVERT_URL_TO_LOWERCASE_BEFORE_COMPARISON
    PATTERN_TYPE_APACHE_ANT
    
    /**=httpSessionContextIntegrationFilter,logoutFilter,authenticationProcessingFilter,
         securityContextHolderAwareRequestFilter,exceptionTranslationFilter,filterInvocationInterceptor
   </value>
  </property>
 </bean>

大体上先介绍一下:
httpSessionContextIntegrationFilter:每次request前 HttpSessionContextIntegrationFilter从Session中获取Authentication对象，在request完后, 又把Authentication对象保存到Session中供下次request使用,此filter必须其他Acegi filter前使用，使之能跨越多个请求。
logoutFilter:用户的注销
authenticationProcessingFilter:处理登陆请求
exceptionTranslationFilter:异常转换过滤器
filterInvocationInterceptor:在访问前进行权限检查

这些就犹如在web.xml声明一系列的过滤器,不过当把他们都声明在spring中就可以享受Spring给我们带来的方便了。

下面就是对这些过滤器的具体声明：
只对有用的地方进行声明，别的地方几乎都是默许的
<!-- ======================== FILTER ======================= -->
 <bean id="httpSessionContextIntegrationFilter"
  class="org.acegisecurity.context.HttpSessionContextIntegrationFilter" />

 <bean id="logoutFilter" class="org.acegisecurity.ui.logout.LogoutFilter">
  <constructor-arg value="/index.htm" />             离开后所转向的位置
  <constructor-arg>
            <list>
                <bean class="org.acegisecurity.ui.logout.SecurityContextLogoutHandler"/>
            </list>
        </constructor-arg>
  <property name="filterProcessesUrl" value="/logout.htm" />        定义用户注销的地址，
 </bean>

下面的这个过滤器，我们根据自己的需求有了自己的实现：

 <bean id="authenticationProcessingFilter" class="subject.web.filter.UserAuthenticationProcessingFilter">
  <property name="authenticationManager" ref="authenticationManager"/>  下面会介绍的用来起到认证管理的作用
  <property name="authenticationFailureUrl" value="/login.htm?error=wrong"/>  登陆失败的地址
  <property name="defaultTargetUrl" value="/login.htm"/>       登陆成功的地址
  <property name="filterProcessesUrl" value="/j_security_check"/>      登陆请求的地址
  <property name="userManager" ref="userManager"/>        自己添加的属性，这样就可以访问到我们的业务逻辑
  <property name="exceptionMappings">   出现异常所对应的地址
            <value>
                org.acegisecurity.AuthenticationException=/login.htm?error=fail     登陆失败                org.acegisecurity.concurrent.ConcurrentLoginException=/login.htm?error=too        已登陆了
            </value>
        </property>
 </bean>
 
 <bean id="securityContextHolderAwareRequestFilter" class="org.acegisecurity.wrapper.SecurityContextHolderAwareRequestFilter"/>

 <bean id="exceptionTranslationFilter" class="org.acegisecurity.ui.ExceptionTranslationFilter">
  <property name="authenticationEntryPoint">
   <bean class="org.acegisecurity.ui.webapp.AuthenticationProcessingFilterEntryPoint">
    <property name="loginFormUrl" value="/login.htm?error=please"/>//如果用户没登陆就想访问，先到这里登陆吧
    <property name="forceHttps" value="false"/>
   </bean>
  </property>
 </bean>
 
 <bean id="filterInvocationInterceptor" class="org.acegisecurity.intercept.web.FilterSecurityInterceptor">
  <property name="authenticationManager" ref="authenticationManager"/>       认证服务
  <property name="accessDecisionManager">
   <bean class="org.acegisecurity.vote.AffirmativeBased">
    <property name="allowIfAllAbstainDecisions" value="false"/>
    <property name="decisionVoters">
     <list>
      <bean class="org.acegisecurity.vote.RoleVoter">
                    <property name="rolePrefix" value=""/>         //这里定义数据库中存放的角色和我们在这里声明的角色间是否需要加个前缀？我没加
                </bean>
     </list>
    </property>
   </bean>
  </property>
  <property name="objectDefinitionSource">
            <value>
                PATTERN_TYPE_APACHE_ANT
               
                /admin.htm*=a         这里就是数据库中对应的tyep a
                /student*=s           由于没有前缀和数据库里一样
                /teacher*=t
            </value>
        </property>
 </bean>
 
 <bean id="loggerListener"
          class="org.acegisecurity.event.authentication.LoggerListener"/>       记录事件

下面就要说明我们的认证服务了，其起到的关键作用就是用来保证用户登陆身份的验证：

它将验证的功能委托给多个Provider，并通过遍历Providers, 以保证获取不同来源的身份认证，若某个Provider能成功确认当前用户的身份，authenticate()方法会返回一个完整的包含用户授权信息的Authentication对象，否则会抛出一个AuthenticationException。

先声明一个管理器吧，在上面的过滤器中都已经用到过了
<!-- ======================== AUTHENTICATION ======================= -->
 <bean id="authenticationManager" class="org.acegisecurity.providers.ProviderManager">
  <property name="providers">
   <list>
    <ref local="daoAuthenticationProvider" />   我仅仅用到 从数据库中读取用户信息验证身份
   </list>
  </property>
  <property name="sessionController">
   <bean id="concurrentSessionController"
    class="org.acegisecurity.concurrent.ConcurrentSessionControllerImpl">
    <property name="maximumSessions">
     <value>1</value>每个用户同时登陆一位
    </property>
    <property name="sessionRegistry">
     <bean id="sessionRegistry" class="org.acegisecurity.concurrent.SessionRegistryImpl" />
    </property>
    <property name="exceptionIfMaximumExceeded" value="true" />
   </bean>
  </property>
 </bean>
 来实现唯一的一个Provider，从数据库验证身份
 <bean id="daoAuthenticationProvider" class="org.acegisecurity.providers.dao.DaoAuthenticationProvider">
  <property name="userDetailsService">
   <bean id="jdbcDaoImpl"
            class="org.acegisecurity.userdetails.jdbc.JdbcDaoImpl">
          <property name="dataSource" ref="dataSource"/>
          <property name="usersByUsernameQuery">
              <value>
                  select user,password,about from user where user = ?        查找用户的查询语句，只需要把你数据库中的用户和密码以及enable相对应上就行
              </value>
          </property>
          <property name="authoritiesByUsernameQuery">
              <value>
                  select user,type from user where user = ?           这里就是把用户和权限对应上，在appfuse中用的两个表，我都放一个表里了，所以就用这一个就行问题的关键是要让它能找到两个字段，构成一个对象
              </value>
          </property>
      </bean>
  </property>
  <property name="userCache"> 缓存都这么写：
   <bean class="org.acegisecurity.providers.dao.cache.EhCacheBasedUserCache">
    <property name="cache">
     <bean class="org.springframework.cache.ehcache.EhCacheFactoryBean">
      <property name="cacheManager">
       <bean class="org.springframework.cache.ehcache.EhCacheManagerFactoryBean"/>
      </property>
      <property name="cacheName" value="userCache"/>
     </bean>
    </property>
   </bean>
  </property>
 </bean>

==============
对于上面登陆请求的处理器我借鉴了springSide，实现的方法如下：
package subject.web.filter;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;

import org.acegisecurity.Authentication;
import org.acegisecurity.context.SecurityContext;
import org.acegisecurity.context.SecurityContextHolder;
import org.acegisecurity.ui.webapp.AuthenticationProcessingFilter;
import org.acegisecurity.userdetails.UserDetails;

import subject.Constants;
import subject.model.User;
import subject.service.UserManager;

public class UserAuthenticationProcessingFilter extends
  AuthenticationProcessingFilter
{
 private UserManager userManager;

 public void setUserManager( UserManager userManager )
 {
  this.userManager = userManager;
 }

 protected boolean requiresAuthentication( HttpServletRequest request ,
   HttpServletResponse response )
 {
  boolean requiresAuth = super.requiresAuthentication( request, response );
  HttpSession httpSession = null;
  try
  {
   httpSession = request.getSession( false );
  }
  catch ( IllegalStateException ignored )
  {
  }
  if ( httpSession != null )
  {
   if ( httpSession.getAttribute( Constants.USER ) == null )
   {
    if ( !requiresAuth )
    {
     SecurityContext sc = SecurityContextHolder.getContext();
     Authentication auth = sc.getAuthentication();
     if ( auth != null
       && auth.getPrincipal() instanceof UserDetails )
     {
      UserDetails ud = (UserDetails) auth.getPrincipal();//上面声明的sql无非就是要包装成这个对象
      User user = userManager.getUser( ud.getUsername() );从业务逻辑里找到用户，放到session里
      httpSession.setAttribute( Constants.USER, user );
     }
    }
   }
  }
  return requiresAuth;
 }
}

在看看我的login.htm在登陆成功时是怎么工作的吧？
public class UserAction extends BaseAction
{
 private UserManager mgr;

 public void setUserManager( UserManager mgr )
 {
  this.mgr = mgr;
 }

 public ActionForward login( ActionMapping mapping , ActionForm form ,
   HttpServletRequest request , HttpServletResponse response )
   throws Exception
 {
  User user = (User) getSessionObject( request, Constants.USER );
  ActionMessages msg = new ActionMessages();
  if ( user != null )
  {
   return new ActionForward(  user.getType() + ".htm", true );成功就去type.htm
  }
  else
  {
   String error = getParameter( request, Constants.ERROR );
   if ( error != null )对于不同的错误，都加以提示
   {
    if ( error.equalsIgnoreCase( "wrong" ) )
     msg.add( "msg", new ActionMessage( "fail.login.wrong" ) );
    else if ( error.equalsIgnoreCase( "too" ) )
     msg.add( "msg", new ActionMessage( "fail.login.too" ) );
    else if ( error.equalsIgnoreCase( "fail" ) )
     msg.add( "msg", new ActionMessage( "fail.login.fail" ) );
    else
     msg.add( "msg", new ActionMessage( "fail.login.please" ) );
   }
   else
    msg.add( "msg", new ActionMessage( "fail.login.please" ) );
  }
  saveErrors( request, msg );
  return mapping.findForward( "fail" );
 }

}

当然，Acegi需要介绍的东西太多了，我只把我这次认为有必要解释的东西写在了上面让大家来参考，作为能google到的东西，比如对于认证的方式还有很多，我就没有详细的介绍，在学习Acegi过程中，把它自带的例子弄清楚很关键，希望大家一起学习一起共勉！

import java.text.*;
import java.util.*;

public class ExpressionModel extends Observable
{
 
 private ArrayList<String> middle;
 private ArrayList<String> right;
 private String input, result;

 public ExpressionModel()
 {
  middle = new ArrayList<String>();
  right = new ArrayList<String>();
 }

 //判断一个字符是不是操作符
 private boolean isOperator( String op )
 {
  if( op.equals("+") || op.equals("-") || op.equals("%")
     ||op.equals("*")|| op.equals("/") || op.equals("(")
     ||op.equals(")") )
    return true;
   
  else return false;
 }

 //得到一个操作符的优先级
 private int priority( String op )
 {
  if( op.equals("+") || op.equals("-") || op.equals("(") )
   return 1;
  else if( op.equals("*") || op.equals("/") || op.equals("%") )
   return 2;
  else
   return 0;
 }
 

//计算两个数和一个运算符得到的结果
 private String calTwoNumber( String op, String a, String b ) throws Exception
 {
  double x = Double.parseDouble( b );
  double y = Double.parseDouble( a );
  double z = 0;
  
  if( op.equals("+") )
   z = x + y;
  else if( op.equals("-") )
   z = x - y;
  else if( op.equals("*") )
   z = x * y;
  else if( op.equals("/") )
   z = x / y;
  else if( op.equals("%") )
   z = x % y;
  else
   z=0;
  
  return Double.toString( z );
 }
 
//将我们输入的中则表达式转换成逆波兰式
 private void turnToRight()
 {
  MyStack stack = new MyStack();
  String op;
  int pos = 0;
  
  StringTokenizer st = new StringTokenizer(input,"+-*/%()",true);
  
  while( st.hasMoreElements() )
   middle.add( st.nextToken() );
  
  while(true)
  {
   if( isOperator( middle.get(pos) ) )
   {
    if( stack.getTop() == -1 || (middle.get(pos)).equals("(") )
    {
     stack.push( middle.get(pos) );
    }
    else
    {
     if( (middle.get(pos)).equals(")") )
     {
      if( !(stack.top()).equals("(") )
      {
       op = stack.pop();
       right.add(op);
      }
     }
     else
     {
      if( priority(middle.get(pos)) <= priority(stack.top()) && stack.getTop() != -1 )
      {
       op = stack.pop();
       if( !op.equals("(") )
        right.add(op);
      }
      stack.push( middle.get(pos) );
     }
    }
   }
   else
    right.add( middle.get(pos) );
   pos++;
   if( pos >= middle.size() )
    break;
  }
  
  while( stack.getTop() != -1 )
  {
   op = stack.pop();
   right.add(op);
  }
 }

 private void calculate( String expression ) throws Exception
 {
  input = expression;
  
  turnToRight();
  
  MyStack stack = new MyStack();
  String op1, op2, is = null;
  Iterator<String> it = right.iterator();
  
  while(it.hasNext())
  {
   is = it.next();
   if( isOperator(is) )
   {
    op1 = stack.pop();
    op2 = stack.pop();
    stack.push( calTwoNumber(is,op1,op2) );
   }
   else stack.push(is);
  }
  
  NumberFormat form = NumberFormat.getInstance();
  form.setMaximumFractionDigits(5);
  
  result = input + "=" + form.format( Double.parseDouble( stack.pop() ) );
  
  setChanged();
  notifyObservers();
 }
 
 public void input(String expression) throws Exception
 {
  calculate(expression);
  middle.clear();
  right.clear();
 }
 
 public String getResult(){
  return result;
 }
 
}



===============MyStack==============


//我们用到的自己的堆栈
package expression;

import java.util.*;

public class MyStack
{
 
 private LinkedList<String> list;
 private int top;
 
 public MyStack()
 {
  list = new LinkedList<String>();
  top = -1;
 }
  
 public void push(String value)
 {
  top++;
  list.addFirst(value);
 }
 
 public String pop()
 {
  String temp = list.getFirst();
  top--;
  list.removeFirst();
  return temp;
 }
 
 public String top()
 {
  return list.getFirst();
 }
 
 public int getTop()
 {
  return top;
 }
 
}

===============ExpressionController========------

//控制器组件，包括一个输入域和两个按纽

package expression;

import java.awt.*;
import java.awt.event.*;
import javax.swing.*;

public class ExpressionController extends JPanel
{
 
 private ExpressionModel expressionModel;  
 private JTextField calTextField;
 
 public ExpressionController( ExpressionModel controllerModel ) {
  
  super();
  
  expressionModel = controllerModel;
  
  calTextField = new JTextField( 15 );
  JButton calButton = new JButton( "计算" );
  JButton delButton = new JButton( "取消" );
  
  calButton.addActionListener(
   new ActionListener()
   {
    public void actionPerformed( ActionEvent event )
    {
     try
     {
      expressionModel.input( calTextField.getText() );
      calTextField.setText("");
     }
     catch ( Exception exception )
     {
      JOptionPane.showMessageDialog (
       ExpressionController.this,
       "请输入有效表达式！", "错误",
       JOptionPane.ERROR_MESSAGE );
      calTextField.setText("");
     }
    }
   }
  );
  
  delButton.addActionListener(
   new ActionListener()
   {
    public void actionPerformed( ActionEvent event )
    {
     try
     {
      calTextField.setText("");
     }
     catch ( Exception exception )
     {
      calTextField.setText("");
     }
    }
   }
  );
  
  setLayout( new FlowLayout() );
  
  add( calTextField );
  add( calButton );
  add( delButton );
 
 }
 
 public Dimension getPreferredSize()
 {
  return new Dimension( 320, 40 );
 }
 
 public Dimension getMinimumSize()
 {
  return getPreferredSize();
 }
 
 public Dimension getMaximumSize()
 {
  return getPreferredSize();
 }
 
}



================ExpressionView ==================
//用来显示结果的视图
package expression;

import java.awt.*;
import java.text.*;
import java.util.*;

import javax.swing.*;
import javax.swing.border.*;

public class ExpressionView extends JPanel implements Observer
{
 
 private ExpressionModel expressionModel;
 private JLabel display = new JLabel();
 
 public ExpressionView( ExpressionModel model ) {
  
  if( model == null )
   throw new NullPointerException();
  
  expressionModel = model;
  expressionModel.addObserver( this );
  
  add( display );
  
  setBackground( Color.white );
  setBorder( new MatteBorder( 1, 1, 1, 1, Color.black ) );
  
 }
 
 public void update( Observable observable, Object object )
 {
  display.setText( expressionModel.getResult() );
 }
 
 public Dimension getPreferredSize()
 {
  return new Dimension( 320, 60 );
 }
 
 public Dimension getMinimumSize()
 {
  return getPreferredSize();
 }
 
 public Dimension getMaximumSize()
 {
  return getPreferredSize();
 }
 
 
}



===================Expression=====================

//最后把这些组装到这里吧

package expression;

import java.awt.*;
import java.awt.event.*;

import javax.swing.*;
import javax.swing.border.*;

public class Expression extends JApplet
{
  
 public void init()
 {
  ExpressionModel model = new ExpressionModel();
  ExpressionView view = new ExpressionView( model );
  ExpressionController controller = new ExpressionController( model );
  
  Container contentPane = getContentPane();
  contentPane.add( view, BorderLayout.CENTER );
  contentPane.add( controller, BorderLayout.SOUTH );
  
  setSize( 320, 100 );
  
 }
  
}

把这几个类打包到一个jar文件后，再创建个htm文件来访问它

<object
    classid = "clsid:8AD9C840-044E-11D1-B3E9-00805F499D93"
    codebase = "http://java.sun.com/update/1.5.0/jinstall-1_5-windows-i586.cab#Version=5,0,0,5"
    WIDTH = 320 HEIGHT = 100 >
    <PARAM NAME = CODE VALUE = "expression.Expression" >
    <PARAM NAME = ARCHIVE VALUE = "expression.jar" >
    <param name = "type" value = "application/x-java-applet;version=1.5">
    <param name = "scriptable" value = "false">
</object>

这样就行了，不过你的机器需要安装jre 5

 <filter-mapping>
        <filter-name>rewriteFilter</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>


它所应用到的包存放在lib下的urlrewrite-3.0-beta.jar

它和以上的两部分，以及/web-inf/urlrewrite.xml构成了对url地址的美化

打开这个文件，我们可以看到以下的声明：

<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE urlrewrite PUBLIC "-//tuckey.org//DTD UrlRewrite 3.0//EN"
    "http://tuckey.org/res/dtds/urlrewrite3.0.dtd">

<!-- https://urlrewrite.dev.java.net/manual/3.0 -->
<urlrewrite>
    <rule>
        <from>^/user/(.*).html$</from>
        <to type="forward">/editUser.html\?username=$1</to>
    </rule>
</urlrewrite>

这样系统就完成了url地址的editUser.html?username=****的美化

如将
http://localhost/aaa/bbb.jsp?id=99&name=abc
表现为：
http://localhost/aaa/bbb/99_abc.html
配置如下：
<rule>
<from>/aaa/bbb/([0-9]+)_([a-z]+).html</from>
<to>/../aaa/bbb.jsp?id=$1&name=$2</to>
</rule>

public class CheckTag extends TagSupport
{
    private static final long serialVersionUID = 879137944441282895L;
    private String check = "";//用来验证的变量
    private String url = "index.jsp";//出现错误要去的页面
    private String msg = "";//错误的提示
    private String scope = "";//要严整变量的范围
    private String to = "go"; //如果验证失败，是将页面后退，还是定位到哪里？

    public String getTo()
    {
        return to;
    }

    public void setTo( String to )
    {
        this.to = to;
    }

    public String getMsg()
    {
        return msg;
    }

    public void setMsg( String msg )
    {
        this.msg = msg;
    }

    public String getScope()
    {
        return scope;
    }

    public void setScope( String scope )
    {
        this.scope = scope;
    }

    public String getCheck()
    {
        return check;
    }

    public void setCheck( String check )
    {
        this.check = check;
    }

    public String getUrl()
    {
        return url;
    }

    public void setUrl( String url )
    {
        this.url = url;
    }

    public int doStsrtTag() throws JspException
    {
        return SKIP_BODY;
    }

    public int doEndTag() throws JspException
    {
        boolean valid = false;//先设为不可用
        if ( scope.equalsIgnoreCase( "request" ) )//如果要检查request范围
        {
            valid = CheckUtil.checkRequestAttribute( pageContext.getRequest(),
                    check );
        }
        else if ( scope.equalsIgnoreCase( "session" ) )
        {
            valid = CheckUtil.checkSession( pageContext.getSession(), check );
        }
        else if ( scope.equalsIgnoreCase( "parameter" ) )
        {
            valid = CheckUtil.checkParameter( pageContext.getRequest(), check );
        }
        else if ( scope.equalsIgnoreCase( "application" ) )
        {
            valid = CheckUtil.checkApp( pageContext.getServletContext(), check );
        }
        if ( valid ) return EVAL_PAGE;//如果可用就继续执行此页的其余部分
        else
        {//否则，哈哈
            try
            {
                if ( to.equalsIgnoreCase( "go" ) ) //现在失败了，就看怎么回到你该到的地方
                    HtmlUtil.callParentGo(
                        pageContext.getOut(), msg, url );//将浏览器定位到URL 
                else
                    HtmlUtil.callBack( pageContext.getOut(), msg );//后退一下页面来阻止
                return SKIP_PAGE;//跳过页面的其余部分，不执行
            }
            catch ( Exception e )
            {
                throw new JspException( e.toString() );
            }
        }
    }

    public void release()
    {
        super.release();
        check = "";
        url = "";
        msg = "";
        scope = "";
    }
}


下面是用到的htmlUtil部分：

public static void callParentGo( Writer out, String msg, String url )
            throws IOException
    {
        out.write( "<script language=\"javascript\">" );
        out.write( "alert(\"" + msg + "\");" );
        out.write( "parent.location.href=\"" + url + "\";" );
        out.write( "</script>" );
    }
public static void callBack( Writer out, String msg ) throws IOException
    {
        out.write( "<script language=\"javascript\">" );
        out.write( "alert(\"" + msg + "\");" );
        out.write( "parent.history.back();" );
        out.write( "</script>" );
    }


写个check.tld部署吧，

<?xml version = "1.0"?>
<taglib>
 <tlibversion>1.0</tlibversion>
 <jspversion>1.1</jspversion>
 <tag>
  <name>check</name>
  <tag-class>com.boya.subject.util.CheckTag</tag-class>
  <attribute>
   <name>check</name>
   <required>true</required>
  </attribute>
  <attribute>
   <name>url</name>
   <required>false</required>
  </attribute>
  <attribute>
   <name>msg</name>
   <required>true</required>
  </attribute>
  <attribute>
   <name>scope</name>
   <required>true</required>
  </attribute>
  <attribute>
   <name>to</name>
   <required>false</required>
  </attribute>
 </tag>
</taglib>


你 只要在每个页面里写下这个就可以判定用户是否登陆了

<%@ taglib prefix="boya" uri="/WEB-INF/check.tld" %>
<boya:check check="admin" msg="管理员尚未登陆，请登陆！" scope ="session"/>

如果没有登陆那么，会自动提示到首页登陆，不错，很完美吧？

当然不是，您可以提出您的见解。。。。

import java.util.Vector;

public class Page<E>
{
    private int current = 1;        //当前页
    private int total = 0;         //总记录数
    private int pages = 0;    //总页数
    private int each = 5;         //每页显示
    private int start = 0;      //每页显示的开始记录数
    private int end = 0;       //每页显示的结束记录数
    private boolean next = false;        //是否有下一页
    private boolean previous = false;  //是否有上一页
    private Vector<E> v = null;    //存放查询结果的容器

    public Page( Vector<E> v ,int per)
    {
        this.v = v;
        each = per;
        total = v.size();   //容器的大小就是总的记录数
        if ( total % each == 0 )
            pages = total / each;       //计算总页数
        else
            pages = total / each + 1;
        if ( current >= pages )
        {
            next = false;
        }
        else
        {
            next = true;
        }
        if ( total < each )
        {
            start = 0;
            end = total;
        }
        else
        {
            start = 0;
            end = each;
        }
    }
   
    public int getCurrent()
    {
        return current;
    }

    public void setCurrent( int current )
    {
        this.current = current;
    }

    public int getEach()
    {
        return each;
    }

    public void setEach( int each )
    {
        this.each = each;
    }

    public boolean isNext()
    {
        return next;
    }

    public void setNext( boolean next )
    {
        this.next = next;
    }

    public boolean isPrevious()
    {
        return previous;
    }

    public void setPrevious( boolean previous )
    {
        this.previous = previous;
    }

    public int getEnd()
    {
        return end;
    }

    public int getPages()
    {
        return pages;
    }

    public int getStart()
    {
        return start;
    }

    public int getTotal()
    {
        return total;
    }

 //获取下一页的对象们  

public Vector<E> getNextPage()
    {
        current = current + 1;
        if ( (current - 1) > 0 )
        {
            previous = true;
        }
        else
        {
            previous = false;
        }
        if ( current >= pages )
        {
            next = false;
        }
        else
        {
            next = true;
        }
        Vector<E> os = gets();
        return os;
    }

 //获取上一页

    public Vector<E> getPreviouspage()
    {
        current = current - 1;
        if ( current == 0 )
        {
            current = 1;
        }
        if ( current >= pages )
        {
            next = false;
        }
        else
        {
            next = true;
        }
        if ( (current - 1) > 0 )
        {
            previous = true;
        }
        else
        {
            previous = false;
        }
        Vector<E> os = gets();
        return os;
    }

 //一开始获取的

    public Vector<E> gets()
    {
        if ( current * each < total )
        {
            end = current * each;
            start = end - each;
        }
        else
        {
            end = total;
            start = each * (pages - 1);
        }
        Vector<E> gets = new Vector<E>();
        for ( int i = start; i < end; i++ )
        {
            E o = v.get( i );
            gets.add( o );
        }
        return gets;
    }
}



 而对于按不同搜索，我们需要一个FormBean，一般的搜索，都是模糊搜索，搜索个大概，而且输入的信息中文的比重也会很大，所以，我把对中文字符的转换放到了这个BEAN里，在进行select * from * where like这样的查询时，如果是like ''这样就可以得到所有的记录了，我便用这个来对付没有输入查询关键字的情况，而like '%*%'可以匹配关键字，而%%也在这里添加上了！

package com.boya.subject.view;

import java.io.UnsupportedEncodingException;
import javax.servlet.http.HttpServletRequest;
import org.apache.struts.action.ActionForm;
import org.apache.struts.action.ActionMapping;

public class SearchForm extends ActionForm
{
    private static final long serialVersionUID = 1L;
    private String key;
    private String from;

    public String getFrom()
    {
        return from;
    }

    public void setFrom( String from )
    {
        this.from = from;
    }

      public void reset( ActionMapping mapping, HttpServletRequest req )
    {
        this.key = null;
    }

    public String getKey()
    {
        return key;
    }

    public void setKey( String key )
    {
        try
        {
            key = new String( key.getBytes( "iso-8859-1" ), "gb2312" );
        }
        catch ( UnsupportedEncodingException e )
        {
            e.printStackTrace();
        }
        this.key = "%" + key + "%";
    }
   
    public String getAny(){
        return "%%";
    }
}
前期都做好了，我现在就要开始访问这个Action了，可是这个控制器还没写呢！这里是代码

public class AdminUserAction extends AdminAction
{
    private Vector<Student> ss; //用来装结果的容器
    private Page<Student> ps; //分页显示的PAGE对象

    protected ActionForward executeAction( ActionMapping mapping,
            ActionForm form, HttpServletRequest req, HttpServletResponse res )
            throws Exception
    {
        if ( !isSupper( req ) )
        {
            return notSupper( res );//如果不是超级管理员怎么办？
        }
        Service service = getService();//获取业务逻辑
        SearchForm sf = (SearchForm) form;//获取搜索FORM
        String op = req.getParameter( "op" );//获取用户对页面的操作
        String search = req.getParameter( "search" );//是否执行了搜索
        Vector<Student> temp = null; //用于存放临时反馈给用户的结果容器
                if ( op == null )//如果用户没有执行上/下一页的操作
                {
                    if ( search != null )//用户如果执行了搜索
                    {
                        if ( sf.getFrom().equalsIgnoreCase( "class" ) )//如果是按班级查找
                        {
                            ss = service.getAllStudentBySchoolClassForAdmin( sf
                                    .getKey() );//获取from的关键字
                        }
                        else if ( sf.getFrom().equalsIgnoreCase( "name" ) )//如果是按姓名查找
                        {
                            ss = service.getAllStudentByNameForAdmin( sf
                                    .getKey() );
                        }
                        else if ( sf.getFrom().equalsIgnoreCase( "user" ) )//如果是按用户名查找
                        {
                            ss = service.getAllStudentByUserForAdmin( sf
                                    .getKey() );
                        }
                        else
                        {
                            ss = service.getAllStudentBySnForAdmin( sf.getKey() );//按学号查找
                        }
                        form.reset( mapping, req );//重置搜索表单
                    }
                    else
                    {
                        ss = service.getAllStudentForAdmin( sf.getAny() ); //用户未执行查找就显示全部，
                    }
                    if ( ss != null && ss.size() != 0 )//如果查找不为空，有记录，那就创建一个分页对象
                    {
                        ps = new Page<Student>( ss, 10 );//将查询结果和每页显示记录数作为参数构件对象
                        temp = ps.gets();//并获取第一页
                    }
                }
                else//如果用户执行了操作
                {
                    if ( op.equals( "next" ) )//操作是下一页
                    {
                        temp = ps.getNextPage();
                    }
                    if ( op.equals( "previous" ) )//操作是上一页
                    {
                        temp = ps.getPreviouspage();
                    }
                }
                req.setAttribute( "search", SelectUtil.studentSearch() );//把搜索用到的表单放到request中
                req.setAttribute( "students", temp );//该页显示的学生
                req.setAttribute( "page", ps );//分页对象
                return mapping.findForward( "student" );//请求转发
    }
}


用到SelectUtil中的代码如下：
/**
     * 获取学生查找类别的select
     * @return 学生查找类别
     * 2006-5-17 9:06:12
     */
    public static Vector<LabelValueBean> studentSearch()
    {
        Vector<LabelValueBean> s = new Vector<LabelValueBean>();
        s.add( new LabelValueBean( "按学号查找", "sn" ) );
        s.add( new LabelValueBean( "按班级查找", "class" ) );
        s.add( new LabelValueBean( "按姓名查找", "name" ) );
        s.add( new LabelValueBean( "按用户查找", "user" ) );
        return s;
    }
在看页面视图前先让我们看看Model吧，

public class Student extends User
{
    private String sn;
    private SchoolClass schoolClass; //这里的班级做为了一种对象，我们在视图显示的时候就有了一层嵌套

    public SchoolClass getSchoolClass()
    {
        return schoolClass;
    }

    public void setSchoolClass( SchoolClass schoolClass )
    {
        this.schoolClass = schoolClass;
    }

    public String getSn()
    {
        return sn;
    }

    public void setSn( String sn )
    {
        this.sn = sn;
    }

    public String getType()
    {
        return "student";
    }
}
在了解了model后，还是看看视图吧，


先放个查询表单：

<html:javascript dynamicJavascript="true" staticJavascript="true" formName="SearchForm" />
<html:form action="/adminUser.do?search=true" onsubmit="return validateSearchForm(this)">

<html:select property="from" >
<html:options collection="search" property="value" labelProperty="label" />
</html:select>

<html:text property="key" size="16" maxlength="16"/>

<html:image src="images/search.gif"/>

</html:form>

由于模型中有嵌套，那么我们就将用到Nested标签，其实没有嵌套也可以使用这个标签，下面的是用于显示信息的，用迭迨器进行遍历request范围的students，你不安排范围，他会自动找到的，并把每次遍历的对象起名叫student，并作为层次的根元素，

<logic:iterate id="student" name="students">

<nested:root name="student">

<nested:nest property="schoolClass"><nested:write property="schoolClass"/></nested:nest>//寻找了student的schoolClass属性对象的schoolClass嵌套

<nested:write property="name"/>      //student的名字

<nested:link page="/adminActions.do?method=deleteStudent" paramId="id" paramProperty="id" onclick="return window.confirm('您真的要删除吗？')">删除</nested:link>

</nested:root>

这里是显示分页对象的：

第<bean:write name="page" property="current" />页
共<bean:write name="page" property="pages" />页
        //上一页是否存在
        <logic:equal name="page" property="previous" value="true">
               <html:link page="/adminUser.do?part=student&op=previous">
                <font color="6795b4">上一页</font>
               </html:link>&nbsp;&nbsp; 
        </logic:equal>
        <logic:notEqual name="page" property="previous" value="true">上一页&nbsp;&nbsp;  </logic:notEqual>
        
       //下一页是否存在
         <logic:equal name="page" property="next" value="true">
         <html:link page="/adminUser.do?part=student&op=next">
          <font color="6795b4">下一页</font>
         </html:link>&nbsp;&nbsp;  </logic:equal>
        <logic:notEqual name="page" property="next" value="true">下一页&nbsp;&nbsp;  </logic:notEqual>
        

共有<bean:write name="page" property="total" />条数据

</logic:iterate>

到这里不知道您看明白了多少，在我的这个JSP页里几乎没有任何的业务逻辑，这样的设计就比把HTML和JAVA搀杂在一起好了很多。