• 丰搜首页
• 文档中心
• 视频中心
• 丰搜贴吧
• 问题集锦
• 更多功能

选择显示字体大小

• 最大
• 较大
• 标准

acegi简介

           acegi安全系统，是一个用于spring framework的安全框架，能够和目前流行的web容器无缝集成。它使用了spring的方式提供了安全和认证安全服务，包括使用bean context，拦截器和面向接口的编程方式。因此，acegi安全系统能够轻松地适用于复杂的安全需求。
       安全涉及到两个不同的概念，认证和授权。前者是关于确认用户是否确实是他们所宣称的身份。授权则是关于确认用户是否有允许执行一个特定的操作。
       在acegi安全系统中，需要被认证的用户，系统或代理称为"principal"。acegi安全系统和其他的安全系统不同，它并没有角色和用户组的概念。
acegi系统设计
  关键组件
      acegi安全系统包含以下七个关键的功能组件：
        1 authentication对象，包含了principal，credential和principal的授权信息。同时还可以包含关于发起认证请求的客户的其他信息，如ip地址。
        2 contextholder对象，使用threadlocal储存authentication对象的地方。
        3 authenticationmanager，用于认证contextholder中的authentication对象。
        4 accessdecissionmanager，用于授权一个特定的操作。
        5 runasmanager，当执行特定的操作时，用于选择性地替换authentication对象。
        6 secure object拦截器，用于协调authenticationmanager，accessdecissionmanager，runasmanager和特定操作的执行。
        7 objectdefinitionsource，包含了特定操作的授权定义。
      这七个关键的功能组件的关系如下图所示（图中灰色部分是关键组件）：


安全管理对象
       acegi安全系统目前支持两类安全管理对象。
       第一类的安全管理对象管理aop alliance的methodinvocation，开发人员可以用它来保护spring容器中的业务对象。为了使spring管理的bean可以作为methodinvocation来使用，bean可以通过proxyfactorybean和beannameautoproxycreator来管理，就像在spring的事务管理一样使用。
       第二类是filterinvocation。它用过滤器（filter）来创建，并简单地包装了http的servletrequest，servletresponse和filterchain。filterinvocation可以用来保护http资源。通常，开发人员并不需要了解它的工作机制，因为他们只需要将filter加入web.xml，acegi安全系统就可以工作了。

安全配置参数
       每个安全管理对象都可以描述数量不限的各种安全认证请求。例如，methodinvocation对象可以描述带有任意参数的任意方法的调用，而filterinvocation可以描述任意的http url。
       acegi安全系统需要记录应用于每个认证请求的安全配置参数。例如，对于bankmanager.getbalance（int accountnumber）方法和bankmanager.approveloan（int applicationnumber）方法，它们需要的认证请求的安全配置很不相同。
       为了保存不同的认证请求的安全配置，需要使用配置参数。从实现的视角来看，配置参数使用configattribute接口来表示。acegi安全系统提供了configattribute接口的一个实现，securityconfig，它把配置参数保存为一个字符串。
       configattributedefinition类是configattribute对象的一个简单的容器，它保存了和特定请求相关的configattribute的集合。
       当安全拦截器收到一个安全认证请求时，需要决定应用哪一个配置参数。换句话说，它需要找出应用于这个请求的configattributedefinition对象。这个查找的过程是由objectdefinitionsource接口来处理的。这个接口的主要方法是public configattributedefinition getattributes(object object)，其中object参数是一个安全管理对象。因为安全管理对象包含有认证请求的详细信息，所以objectdefinitionsource接口的实现类可以从中获得所需的详细信息，以查找相关的configattributedefiniton对象。


acegi如何工作
       为了说明acegi安全系统如何工作，我们设想一个使用acegi的例子。通常，一个安全系统需要发挥作用，它必须完成以下的工作：
      1 首先，系统从客户端请求中获得principal和credential；
      2 然后系统认证principal和credential信息；
      3 如果认证通过，系统取出principal的授权信息；
      4 接下来，客户端发起操作请求；
      5 系统根据预先配置的参数检查principal对于该操作的授权；
      6 如果授权检查通过则执行操作，否则拒绝。
      那么，acegi安全系统是如何完成这些工作的呢？首先，我们来看看acegi安全系统的认证和授权的相关类：
      安全拦截器的抽象基类，它包含有两个管理类，authenticationmanager和accessdecisionmanager。authenticationmanager用于认证contextholder中的authentication对象（包含了principal，credential和principal的授权信息）；accessdecissionmanager则用于授权一个特定的操作。

      下面来看一个methodsecurityinterceptor的例子：

      <bean id=&quot;bankmanagersecurity&quot; 
                     class=&quot.net.sf.acegisecurity.intercept.method.methodsecurityinterceptor&quot;>
             <property name=&quot;validateconfigattributes&quot;>
                    <value>true</value>
            </property>
            <property name=&quot;authenticationmanager&quot;>
                   <ref bean=&quot;authenticationmanager&quot;/>
            </property>
            <property name=&quot;accessdecisionmanager&quot;>
                  <ref bean=&quot;accessdecisionmanager&quot;/>
            </property>
            <property name=&quot;objectdefinitionsource&quot;>
                  <value>
                    .net.sf.acegisecurity.context.bankmanager.delete*=
                             role_supervisor,run_as_server
                    .net.sf.acegisecurity.context.bankmanager.getbalance=
                             role_teller,role_supervisor,banksecurity_customer,run_
                  </value>
            </property>
      </bean> 

      上面的配置文件中，methodsecurityinterceptor是abstractsecurityinterceptor的一个实现类。它包含了两个管理器，authenticationmanager和accessdecisionmanager。这两者的配置如下：
      

<bean id=&quot;authenticationdao&quot; class=&quot.net.sf.acegisecurity.providers.dao.jdbc.jdbcdaoimpl&quot;>
               <property name=&quot;datasource&quot;><ref bean=&quot;datasource&quot;/></property>
      </bean>
      <bean id=&quot;daoauthenticationprovider&quot; 
                     class=&quot.net.sf.acegisecurity.providers.dao.daoauthenticationprovider&quot;>
               <property name=&quot;authenticationdao&quot;><ref bean=&quot;authenticationdao&quot;/></property>
      </bean>
      <bean id=&quot;authenticationmanager&quot; class=&quot.net.sf.acegisecurity.providers.providermanager&quot;>
               <property name=&quot;providers&quot;>
                      <list><ref bean=&quot;daoauthenticationprovider&quot;/></list>
               </property>
      </bean>
      <bean id=&quot;rolevoter&quot; class=&quot.net.sf.acegisecurity.vote.rolevoter&quot;/>
      <bean id=&quot;accessdecisionmanager&quot; class=&quot.net.sf.acegisecurity.vote.affirmativebased&quot;>
               <property name=&quot;allowifallabstaindecisions&quot;><value>false</value></property>
               <property name=&quot;decisionvoters&quot;>
                      <list><ref bean=&quot;rolevoter&quot;/></list>
               </property>
      </bean>

       准备工作做好了，现在我们来看看acegi安全系统是如何实现认证和授权机制的。以使用http basic认证的应用为例子，它包括下面的步骤：
       1. 用户登录系统，acegi从acegisecurity.ui子系统的安全拦截器（如basicprocessingfilter）中得到用户的登录信息（包括principal和credential）并放入authentication对象，并保存在contextholder对象中；
       2. 安全拦截器将authentication对象交给authenticationmanager进行身份认证，如果认证通过，返回带有principal授权信息的authentication对象。此时contextholder对象的authentication对象已拥有principal的详细信息；
       3. 用户登录成功后，继续进行业务操作；
       4. 安全拦截器（bankmanagersecurity）收到客户端操作请求后，将操作请求的数据包装成安全管理对象（filterinvocation或methodinvocation对象）；
       5. 然后，从配置文件（objectdefinitionsource）中读出相关的安全配置参数configattributedefinition；
       6. 接着，安全拦截器取出contextholder中的authentication对象，把它传递给authenticationmanager进行身份认证，并用返回值更新contextholder的authentication对象；
       7. 将authentication对象，configattributedefinition对象和安全管理对象（secure object）交给accessdecisionmanager，检查principal的操作授权；
       8. 如果授权检查通过则执行客户端请求的操作，否则拒绝；

accessdecisionvoter
       注意上节的accessdecisionmanager是一个affirmativebased类，它对于用户授权的投票策略是，只要通过其中的一个授权投票检查，即可通过；它的allowifallabstaindecisions属性值是false，意思是如果所有的授权投票是都是弃权，则通不过授权检查。
       acegi安全系统包括了几个基于投票策略的accessdecisionmanager，上节的rolevoter就是其中的一个投票策略实现，它是accessdecisionvoter的一个子类。accessdecisionvoter的具体实现类通过投票来进行授权决策，accessdecisionmanager则根据投票结果来决定是通过授权检查，还是抛出accessdeniedexception例外。
       accessdecisionvoter接口共有三个方法：
public int vote(authentication authentication, object object, configattributedefinition config);
public boolean supports(configattribute attribute);
public boolean supports(class clazz);
       其中的vote方法返回int返回值，它们是accessdecisionvoter的三个静态成员属性：access_abstain,，access_denied和access_granted，它们分别是弃权，否决和赞成。
       acegi安全系统中，使用投票策略的accessdecisionmanager共有三个具体实现类：affirmativebased、consensusbased和unanimousbased。它们的投票策略是，affirmativebased类只需有一个投票赞成即可通过；consensusbased类需要大多数投票赞成即可通过；而unanimousbased类需要所有的投票赞成才能通过。
       rolevoter类是一个acegi安全系统accessdecisionvoter接口的实现。如果configattribute以role_开头，rolevoter则进行投票。如果grantedauthority的getautority方法的string返回值匹配一个或多个以role_开头的configattribute，则投票通过，否则不通过。如果没有以role_开头的configattribute，rolevoter则弃权。

安全拦截器
  拦截器如何工作
  methodinvocation拦截器
  filterinvocation拦截器
认证
  认证请求
  认证管理器
  authentication provider
授权
  access decision manager
  voting decision manager
  授权管理推荐
contextholder的用户接口
  用户接口目标
  http会话认证
  http basic认证

1、log4j的概念
   log4j中有三个主要的组件，它们分别是logger、appender和layout，log4j 允许开发人员定义多个logger，每个logger拥有自己的名字，logger之间通过名字来表明隶属关系。有一个logger称为root，它永远 存在，且不能通过名字检索或引用，可以通过logger.getrootlogger()方法获得，其它logger通过 logger.getlogger(string name)方法。
   appender则是用来指明将所有的log信息存放到什么地方，log4j中支持多种appender，如 console、files、gui components、nt event loggers等，一个logger可以拥有多个appender，也就是你既可以将log信息输出到屏幕，同时存储到一个文件中。
   layout的作用是控制log信息的输出方式，也就是格式化输出的信息。
   log4j中将要输出的log信息定义了5种级别，依次为debug、info、warn、error和fatal，当输出时，只有级别高过配置中规定的 级别的信息才能真正的输出，这样就很方便的来配置不同情况下要输出的内容，而不需要更改代码，这点实在是方便啊。

2、log4j的配置文件
  虽然可以不用配置文件，而在程序中实现配置，但这种方法在如今的系统开发中显然是不可取的，能采用配置文件的地方一定一定要用配置文件。log4j支持两 种格式的配置文件：xml格式和java的property格式，本人更喜欢后者，首先看一个简单的例子吧，如下：

 log4j.rootlogger=debug, stdout, r
  log4j.appender.stdout=org.apache.log4j.consoleappender
  log4j.appender.stdout.layout=org.apache.log4j.patternlayout

  # pattern to output the caller's file name and line number.
  log4j.appender.stdout.layout.conversionpattern=%5p [%t] (%f:%l) - %m%n

  log4j.appender.r=org.apache.log4j.rollingfileappender
  log4j.appender.r.file=example.log
  log4j.appender.r.maxfilesize=100kb

  # keep one backup file
  log4j.appender.r.maxbackupindex=1

  log4j.appender.r.layout=org.apache.log4j.patternlayout
  log4j.appender.r.layout.conversionpattern=%p %t %c - %m%n

        

  首先，是设置root，格式为 log4j.rootlogger=[level],appendername, ...，其中level就是设置需要输出信息的级别，后面是appender的输出的目的地，appendername就是指定日志信息输出到哪个地方。您可以同时指定多个输出目的地。配置日志信息输出目的地appender，其语法为
  log4j.appender.appendername = fully.qualified.name.of.appender.class
  log4j.appender.appendername.option1 = value1
  ...
  log4j.appender.appendername.option = valuen
log4j提供的appender有以下几种：
  org.apache.log4j.consoleappender（控制台）
  org.apache.log4j.fileappender（文件）
  org.apache.log4j.dailyrollingfileappender（每天产生一个日志文件）
  org.apache.log4j.rollingfileappender（文件大小到达指定尺寸的时候产生新文件）
  org.apache.log4j.writerappender（将日志信息以流格式发送到任意指定的地方）
配置日志信息的格式（布局），其语法为：
  log4j.appender.appendername.layout = fully.qualified.name.of.layout.class
  log4j.appender.appendername.layout.option1 = value1
  ....
  log4j.appender.appendername.layout.option = valuen
log4j提供的layout有以下几种：
  org.apache.log4j.htmllayout（以html表格形式布局），
  org.apache.log4j.patternlayout（可以灵活地指定布局模式），
  org.apache.log4j.simplelayout（包含日志信息的级别和信息字符串），
  org.apache.log4j.ttcclayout（包含日志产生的时间、线程、类别等等信息）

3、log4j在程序中的使用
  要在自己的类中使用log4j，首先声明一个静态变量logger logger=logger.getlog("classname")；在使用之前，用propertyconfigurator.configure ("配置文件")配置一下，现在就可以使用了，用法如下：logger.debug("debug message")或者logger.info("info message")，看下面一个小例子：

 import com.foo.bar;
  import org.apache.log4j.logger;
  import org.apache.log4j.propertyconfigurator;
  public class myapp {
    static logger logger = logger.getlogger(myapp.class.getname());
    public static void main(string[] args) {
      // basicconfigurator replaced with propertyconfigurator.
      propertyconfigurator.configure(args[0]);
      logger.info("entering application.");
      bar bar = new bar();
      bar.doit();
      logger.info("exiting application.");
    }
  }

[简介]

对于一个典型的web应用，完善的认证和授权机制是必不可少的，在springframework中，juergen hoeller提供的范例jpetstore给了一些这方面的介绍，但还远远不够，acegi是一个专门为springframework提供安全机制的 项目，全称为acegi security system for spring，当前版本为0.5.1，就其目前提供的功能，应该可以满足绝大多数应用的需求。

本文的主要目的是希望能够说明如何在基于spring构架的web应用中使用acegi，而不是详细介绍其中的每个接口、每个类。注意，即使对已经存在的spring应用，通过下面介绍的步骤，也可以马上享受到acegi提供的认证和授权。

[基础工作]
在你的web应用的lib中添加acegi下载包中的acegi-security.jar

[web.xml]
实现认证和授权的最常用的方法是通过filter，acegi亦是如此，通常acegi需要在web.xml添加以下5个filter:

<filter>
  <filter-name>acegi channel processing filter</filter-name>
  <filter-class>.net.sf.acegisecurity.util.filtertobeanproxy</filter-class>
  <init-param>
    <param-name>targetclass</param-name>
    <param-value>.net.sf.acegisecurity.securechannel.channelprocessingfilter</param-value>
  </init-param>
</filter>
<filter>
  <filter-name>acegi authentication processing filter</filter-name>
  <filter-class>.net.sf.acegisecurity.util.filtertobeanproxy</filter-class>
  <init-param>
    <param-name>targetclass</param-name>
    <param-value>.net.sf.acegisecurity.ui.webapp.authenticationprocessingfilter</param-value>
  </init-param>
</filter>
<filter>
  <filter-name>acegi http basic authorization filter</filter-name>
  <filter-class>.net.sf.acegisecurity.util.filtertobeanproxy</filter-class>
  <init-param>
    <param-name>targetclass</param-name>
    <param-value>.net.sf.acegisecurity.ui.basicauth.basicprocessingfilter</param-value>
  </init-param>
</filter>
<filter>
  <filter-name>acegi security system for spring auto integration filter</filter-name>
  <filter-class>.net.sf.acegisecurity.ui.autointegrationfilter</filter-class>
</filter>
<filter>
  <filter-name>acegi http request security filter</filter-name>
  <filter-class>.net.sf.acegisecurity.util.filtertobeanproxy</filter-class>
  <init-param>
    <param-name>targetclass</param-name>
    <param-value>.net.sf.acegisecurity.intercept.web.securityenforcementfilter</param-value>
  </init-param>
</filter>

最先引起迷惑的.net.sf.acegisecurity.util.filtertobeanproxy，acegi自己的文档上解释是： “what  filtertobeanproxy does is delegate the filter's methods through to a bean which is obtained from the
spring application context. this enables the bean to benefit from the spring application context lifecycle support and configuration flexibility.”，如希望深究的话，去看看源代码应该不难理解。

再下来就是添加filter-mapping了：

<filter-mapping>
  <filter-name>acegi channel processing filter</filter-name>
  <url-pattern>/*</url-pattern>
</filter-mapping>
<filter-mapping>
  <filter-name>acegi authentication processing filter</filter-name>
  <url-pattern>/*</url-pattern>
</filter-mapping>
<filter-mapping>
  <filter-name>acegi http basic authorization filter</filter-name>
  <url-pattern>/*</url-pattern>
</filter-mapping>
<filter-mapping>
  <filter-name>acegi security system for spring auto integration filter</filter-name>
  <url-pattern>/*</url-pattern>
</filter-mapping>
<filter-mapping>
  <filter-name>acegi http request security filter</filter-name>
  <url-pattern>/*</url-pattern>
</filter-mapping>

这里，需要注意以下两点：
1) 这几个filter的顺序是不能更改的，顺序不对将无法正常工作；
2) 如果你的应用不需要安全传输，如https，则将"acegi channel processing filter"相关内容注释掉即可；
3) 如果你的应用不需要spring提供的远程访问机制，如hessian and burlap，将"acegi http basic authorization
filter"相关内容注释掉即可。

[applicationcontext.xml]
接下来就是要添加applicationcontext.xml中的内容了，从刚才filtertobeanfactory的解释可以看出，真正的filter都
在spring的applicationcontext中管理：

1) 首先，你的数据库中必须具有保存用户名和密码的table，acegi要求table的schema必须如下：

create table users (
    username varchar(50) not null primary key,
    password varchar(50) not null,
    enabled bit not null
);
create table authorities (
    username varchar(50) not null,
    authority varchar(50) not null
);
create unique index ix_auth_username on authorities ( username, authority );
alter table authorities add constraint fk_authorities_users foreign key (username) references users
(username);

2) 添加访问你的数据库的datasource和acegi的jdbcdao，如下：

<bean id=&quot;datasource&quot; class=&quot;org.springframework.jdbc.datasource.drivermanagerdatasource&quot;>
  <property name=&quot;driverclassname&quot;><value>${jdbc.driverclassname}</value></property>
  <property name=&quot;url&quot;><value>${jdbc.url}</value></property>
  <property name=&quot;username&quot;><value>${jdbc.username}</value></property>
  <property name=&quot;password&quot;><value>${jdbc.password}</value></property>
</bean>
<bean id=&quot;jdbcdaoimpl&quot; class=&quot.net.sf.acegisecurity.providers.dao.jdbc.jdbcdaoimpl&quot;>
  <property name=&quot;datasource&quot;><ref bean=&quot;datasource&quot;/></property>
</bean>

3) 添加daoauthenticationprovider:

<bean id=&quot;daoauthenticationprovider&quot; class=&quot.net.sf.acegisecurity.providers.dao.daoauthenticationprovider&quot;>
  <property name=&quot;authenticationdao&quot;><ref bean=&quot;authenticationdao&quot;/></property>
  <property name=&quot;usercache&quot;><ref bean=&quot;usercache&quot;/></property>
</bean>

<bean id=&quot;usercache&quot; class=&quot.net.sf.acegisecurity.providers.dao.cache.ehcachebasedusercache&quot;>
  <property name=&quot;minutestoidle&quot;><value>5</value></property>
</bean>

如果你需要对密码加密，则在daoauthenticationprovider中加入：<property name=&quot;passwordencoder&quot;><ref
bean=&quot;passwordencoder&quot;/></property>，acegi提供了几种加密方法，详细情况可看包
.net.sf.acegisecurity.providers.encoding

4) 添加authenticationmanager:

<bean id=&quot;authenticationmanager&quot; class=&quot.net.sf.acegisecurity.providers.providermanager&quot;>
  <property name=&quot;providers&quot;>
    <list>
      <ref bean=&quot;daoauthenticationprovider&quot;/>
    </list>
   </property>
</bean>

5) 添加accessdecisionmanager:

<bean id=&quot;accessdecisionmanager&quot; class=&quot.net.sf.acegisecurity.vote.affirmativebased&quot;>
  <property name=&quot;allowifallabstaindecisions&quot;>
    <value>false</value>
  </property>
  <property name=&quot;decisionvoters&quot;>
    <list><ref bean=&quot;rolevoter&quot;/></list>
  </property>
</bean>
<bean id=&quot;rolevoter&quot; class=&quot.net.sf.acegisecurity.vote.rolevoter&quot;/>

6) 添加authenticationprocessingfilterentrypoint:

<bean id=&quot;authenticationprocessingfilterentrypoint&quot; 
class=&quot.net.sf.acegisecurity.ui.webapp.authenticationprocessingfilterentrypoint&quot;>
  <property name=&quot;loginformurl&quot;><value>/acegilogin.jsp</value></property>
  <property name=&quot;forcehttps&quot;><value>false</value></property>
</bean>

其中acegilogin.jsp是登陆页面，一个最简单的登录页面如下：

<%@ taglib prefix='c' uri='http://java.sun.com/jstl/core' %>
<%@ page import=&quot.net.sf.acegisecurity.ui.abstractprocessingfilter&quot; %>
<%@ page import=&quot.net.sf.acegisecurity.authenticationexception&quot; %>
<html>
  <head>
    <title>login</title>
  </head>

  <body>
    <h1>login</h1>
    <form action=&quot;<c:url value='j_acegi_security_check'/>&quot; method=&quot;post&quot;>
      <table>
        <tr><td>user:</td><td><input type='text' name='j_username'></td></tr>
        <tr><td>password:</td><td><input type='password' name='j_password'></td></tr>
        <tr><td colspan='2'><input name=&quot;submit&quot; type=&quot;submit&quot;></td></tr>
        <tr><td colspan='2'><input name=&quot;reset&quot; type=&quot;reset&quot;></td></tr>
      </table>
    </form>
  </body>
</html>

7) 添加filterinvocationinterceptor:

<bean id=&quot;filterinvocationinterceptor&quot; 
class=&quot.net.sf.acegisecurity.intercept.web.filtersecurityinterceptor&quot;>
  <property name=&quot;authenticationmanager&quot;>
    <ref bean=&quot;authenticationmanager&quot;/>
  </property>
  <property name=&quot;accessdecisionmanager&quot;>
    <ref bean=&quot;accessdecisionmanager&quot;/>
  </property>
  <property name=&quot;objectdefinitionsource&quot;>
    <value>
      convert_url_to_lowercase_before_comparison
      \a/sec/administrator.*\z=role_supervisor
      \a/sec/user.*\z=role_teller
    </value>
  </property>
</bean>

这里请注意，要objectdefinitionsource中定义哪些页面需要权限访问，需要根据自己的应用需求进行修改，我上面给出
的定义的意思是这样的：
a. convert_url_to_lowercase_before_comparison意思是在比较请求路径时全部转换为小写
b. \a/sec/administrator.*\z=role_supervisor意思是只有权限为role_supervisor才能访问/sec/administrator*的页面
c. \a/sec/user.*\z=role_teller意思是只有权限为role_teller的用户才能访问/sec/user*的页面

8) 添加securityenforcementfilter:

<bean id=&quot;securityenforcementfilter&quot; class=&quot.net.sf.acegisecurity.intercept.web.securityenforcementfilter&quot;>
  <property name=&quot;filtersecurityinterceptor&quot;>
    <ref bean=&quot;filterinvocationinterceptor&quot;/>
  </property>
  <property name=&quot;authenticationentrypoint&quot;>
    <ref bean=&quot;authenticationprocessingfilterentrypoint&quot;/>
  </property>
</bean>

9) 添加authenticationprocessingfilter:

<bean id=&quot;authenticationprocessingfilter&quot; 
class=&quot.net.sf.acegisecurity.ui.webapp.authenticationprocessingfilter&quot;>
  <property name=&quot;authenticationmanager&quot;>
    <ref bean=&quot;authenticationmanager&quot;/>
  </property>
  <property name=&quot;authenticationfailureurl&quot;>
    <value>/loginerror.jsp</value>
  </property>
  <property name=&quot;defaulttargeturl&quot;>
    <value>/</value>
  </property>
  <property name=&quot;filterprocessesurl&quot;>
    <value>/j_acegi_security_check</value>
  </property>
</bean>

其中authenticationfailureurl是认证失败的页面。

10) 如果需要一些页面通过安全通道的话，添加下面的配置:

<bean id=&quot;channelprocessingfilter&quot; class=&quot.net.sf.acegisecurity.securechannel.channelprocessingfilter&quot;>
  <property name=&quot;channeldecisionmanager&quot;>
    <ref bean=&quot;channeldecisionmanager&quot;/>
  </property>
  <property name=&quot;filterinvocationdefinitionsource&quot;>
    <value>
      convert_url_to_lowercase_before_comparison
      \a/sec/administrator.*\z=requires_secure_channel
      \a/acegilogin.jsp.*\z=requires_secure_channel
      \a/j_acegi_security_check.*\z=requires_secure_channel
      \a.*\z=requires_insecure_channel
    </value>
  </property>
</bean>

<bean id=&quot;channeldecisionmanager&quot; class=&quot.net.sf.acegisecurity.securechannel.channeldecisionmanagerimpl&quot;>
  <property name=&quot;channelprocessors&quot;>
    <list>
      <ref bean=&quot;securechannelprocessor&quot;/>
      <ref bean=&quot;insecurechannelprocessor&quot;/>
    </list>
  </property>
</bean>
<bean id=&quot;securechannelprocessor&quot; class=&quot.net.sf.acegisecurity.securechannel.securechannelprocessor&quot;/>
<bean id=&quot;insecurechannelprocessor&quot; class=&quot.net.sf.acegisecurity.securechannel.insecurechannelprocessor&quot;/>

[缺少了什么？]
acegi目前提供了两种&quot;secure object&quot;，分别对页面和方法进行安全认证管理，我这里介绍的只是利用
filtersecurityinterceptor对访问页面的权限控制，除此之外，acegi还提供了另外一个interceptor――
methodsecurityinterceptor，它结合runasmanager可实现对对象中的方法的权限控制，使用方法可参看acegi自带的文档
和contact范例。

[最后要说的]
本来以为只是说明如何使用acegi而已，应该非常简单，但真正写起来才发现想要条理清楚的理顺所有需要的bean还是很
困难的，但愿我没有遗漏太多东西，如果我的文章有什么遗漏或错误的话，还请参看acegi自带的quick-start范例，但请
注意，这个范例是不能直接拿来用的。
分析和学习spring中的jpetstore用户管理
  存在用户的系统，必然需要用户的登录和认证，今天就通过分析spring中自带的jpetstore的例子来学习一下如何实现在spring构架的系统中用户登录。
1、首先从注册用户开始，先看看jpetstore-servlet.xml中关于注册用户的bean定义，从定义命名中就可以看出下面这段就是注册用户的：
  

<bean name=&quot;/shop/newaccount.do&quot; class=&quot;org.springframework.samples.jpetstore.web.spring.accountformcontroller&quot;>
    <property name=&quot;petstore&quot;><ref bean=&quot;petstore&quot;/></property>
    <property name=&quot;validator&quot;><ref bean=&quot;accountvalidator&quot;/></property>
    <property name=&quot;successview&quot;><value>index</value></property>
  </bean>

1). formview呢？从accountformcontroller的构造函数中得到，原来为editaccountform；  
2). editoaccountform.jsp中显得非常乱，其实没有多少难理解的地方，最主要的是这个form既是添加新用户的，又是编辑用户信息的，所以显得有点乱糟糟的。
2、添加好了新用户，接下来看看如何登录，在jpetstore-servlet中发现这两个相关bean定义，如下：
  

<bean name=&quot;/shop/signon.do&quot; class=&quot;org.springframework.samples.jpetstore.web.spring.signoncontroller&quot;>
    <property name=&quot;petstore&quot;><ref bean=&quot;petstore&quot;/></property>
  </bean>
  <bean name=&quot;/shop/signonform.do&quot; class=&quot;org.springframework.web.servlet.mvc.parameterizableviewcontroller&quot;>
    <property name=&quot;viewname&quot;><value>signonform</value></property>
  </bean>

1). 第二个bean是在运行时用户输入用户名和密码的form，叫做signonform，对于这个 parameterizableviewcontroller，用文档里的话说这是最简单的controller，其作用就是在运行中指向 controller而不是直接指向jsp文件，仅此而已。
2). signonform.jsp，里面就是一个简单的form，其action就是第一个bean，即/shop/signon.do，最需要注意的是 signonforwardaction，其主要作用是forward到需要输入用户名和密码的那个页面上去，这个变量哪里来的呢？看看下面：
  

<bean id=&quot;securehandlermapping&quot; class=&quot;org.springframework.web.servlet.handler.simpleurlhandlermapping&quot;>
    <property name=&quot;interceptors&quot;>
      <list>
        <ref bean=&quot;signoninterceptor&quot;/>
      </list>
    </property>
    <property name=&quot;urlmap&quot;>
      <map>
        <entry key=&quot;/shop/editaccount.do&quot;><ref local=&quot;secure_editaccount&quot;/></entry>
        <entry key=&quot;/shop/listorders.do&quot;><ref local=&quot;secure_listorders&quot;/></entry>
        <entry key=&quot;/shop/neworder.do&quot;><ref local=&quot;secure_neworder&quot;/></entry>
        <entry key=&quot;/shop/vieworder.do&quot;><ref local=&quot;secure_vieworder&quot;/></entry>
      </map>
    </property>
  </bean>

  原来，上面的signoninterceptor实现了prehandle，因此在请求上面的map页面时，首先要经过这个interceptor，看看 signoninterceptor的源码，原来在其中为signon.jsp赋予一个signonforwardaction对象，呵呵，总算明白了。
3). 接下来去学习一下signoncontroller，其主体部分中可以看出，首先取出用户输入的username和password，然后到数据库中验证 有没有这个用户，如果没有这个用户，返回各错误页面；如果成功，首先生成一个usersession对象，在request的session加入这个 usersession，注意这部分代码中给出了pagedlistholder分页的简单使用方法，关于分页显示，以后再学习吧。
3、登录成功后，就可以根据不同的用户设施不同的行为了，取得用户信息，无非就是从session取出usersession即可。

 

关键字 本文所属关键字

相关 与本文相关文章

分类 所有文章关键字导航

标准 网站致力的规范