如何配置攔截器
❶ hibernate 全局攔截器怎麼配置
對於日誌和事件的記錄在每個項目中都會用到，如果在每個manager層中觸發時間記錄的話，會比較難以擴展和維護，所以可配置的日誌和事件記錄在項目中會用到！
首先在spring的配置文件中加入hibernate攔截器
java代碼
<bean
id="sessionFactory"
class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
<property
name="entityInterceptor">
<ref
bean="myInterceptor"/>
</property>
</bean>
<bean
id="myInterceptor"
class="com.creawor.cbsms.util.MyInterceptor"
/>
MyInterceptor攔截器為：
Java代碼
package
com.creawor.cbsms.util;
import
java.io.Serializable;
import
java.lang.reflect.InvocationTargetExceptio
n;
import
java.lang.reflect.Method;
import
java.util.Iterator;
import
javacommon.util.ApplicationContextHolder
;
import
org.hibernate.CallbackException;
import
org.hibernate.EntityMode;
import
org.hibernate.Interceptor;
import
org.hibernate.Transaction;
import
org.hibernate.type.Type;
import
com.creawor.cbsms.event.EventRecord;
import
com.creawor.cbsms.model.CbsChannel;
import
com.creawor.cbsms.model.CbsMessage;
public
class
MyInterceptor
implements
Interceptor{
//刪除時記錄時間
public
void
onDelete(Object
obj,
Serializable
arg1,
Object[]
arg2,
String[]
arg3,
Type[]
arg4)
throws
CallbackException
{
//
TODO
Auto-generated
method
stub
String[]
entitys
=
EventRecord.getDeleteEntitysFireEven
t();
for
(String
entityName
:
entitys)
{
if
(entityName.equals(obj.getClass().getSimpleName()))
{
getEventRecordMethod(entityName,
obj,EventRecord.getDeleteInfo());
}
}
}
//修改時記錄事件
public
boolean
onFlushDirty(Object
obj,
Serializable
id,
Object[]
currentState,
Object[]
previousState
,
String[]
propertyNames,
Type[]
types){
String[]
entitys
=
EventRecord.getUpdateEntitysFireEven
t();
for
(String
entityName
:
entitys)
{
if
(entityName.equals(obj.getClass().getSimpleName()))
{
getEventRecordMethod(entityName,
obj,
EventRecord.getUpdateInfo());
}
}
return
false;
}
public
String
onPrepareStatement(String
arg0)
{
//
TODO
Auto-generated
method
stub
return
arg0;
}
//保存時記錄事件
public
boolean
onSave(Object
obj,
Serializable
arg1,
Object[]
arg2,
String[]
arg3,
Type[]
arg4)
throws
CallbackException
{
//
TODO
Auto-generated
method
stub
String[]
entitys
=
EventRecord.getSaveEntitysFireEvent();
for
(String
entityName
:
entitys)
{
if
(entityName.equals(obj.getClass().getSimpleName()))
{
getEventRecordMethod(entityName,
obj,EventRecord.getSaveInfo());
}
}
return
false;
}
//根據反射機制執行事件記錄類中相應的函數
public
void
getEventRecordMethod(String
entityName,Object
obj,String
info){
try
{
Class[]
parameterTypes
=
{String.class,Class.forName(EventRecord.getPrefixPackageName()+entityName)};
Method
method
=
EventRecord.class.getMethod(EventRecord.getPrefixMethodName()+entityName,
parameterTypes);
Object[]
objs
=
{info,
Class.forName(EventRecord.getPrefixPackageName()+entityName).cast(obj)};
method.invoke((EventRecord)ApplicationContextHolder
.getBean("eventRecord"),objs);
}
catch
(Exception
e)
{
//
TODO
Auto-generated
catch
block
e.printStackTrace();
}
}
事件記錄類：
Java代碼
package
com.creawor.cbsms.event;
import
java.sql.Timestamp;
import
javacommon.util.ApplicationContextHolder
;
import
com.creawor.cbsms..CbsEventDao;
import
com.creawor.cbsms.model.CbsBsc;
import
com.creawor.cbsms.model.CbsBscCells;
import
com.creawor.cbsms.model.CbsChannel;
import
com.creawor.cbsms.model.CbsEvent;
import
com.creawor.cbsms.model.CbsUserRegister;
import
com.creawor.cbsms.service.CbsEventManager;
import
com.creawor.security.model.PermUser;
public
class
EventRecord
{
//
保存時要記錄事件的對象
private
static
String[]
saveEntitysFireEvent
=
{
"CbsBscCells",
"CbsChannel",
"CbsBsc"
};
//
刪除時要記錄事件的對象
private
static
String[]
deleteEntitysFireEvent
=
{
"CbsBscCells",
"CbsChannel",
"CbsBsc"
};
//
更新時要記錄事件的對象
private
static
String[]
updateEntitysFireEvent
=
{
"CbsBscCells",
"CbsChannel",
"CbsBsc"
};
//
包的前綴，反射得到類時使用
private
static
String
prefixPackageName
=
"com.creawor.cbsms.model.";
//
記錄該次操作的登錄用戶名：EventRecord為session范圍
private
String
userName;
//
調用函數的前綴，反射執行函數時使用
private
static
String
prefixMethodName
=
"recordFor";
//
執行save時，事件描述
private
static
String
saveInfo
=
"創建";
//
執行delete時，事件描述
private
static
String
deleteInfo
=
"刪除";
//
執行update時，事件描述
private
static
String
updateInfo
=
"修改";
private
CbsEventManager
cbsEventManager;
//
spring自動注入
public
void
setCbsEventManager(CbsEventManager
cbsEventManager)
{
this.cbsEventManager
=
cbsEventManager;
}
public
void
recordForCbsChannel(String
desc,
CbsChannel
channel)
{
StringBuffer
eventDesc
=
new
StringBuffer(desc);
eventDesc.append("頻道"
+
channel.getChannelName()).append("[").append(
channel.getChannelNum()).append("]");
record(eventDesc.toString(),
null);
}
public
void
recordForCbsBscCells(String
desc,
CbsBscCells
cell)
{
StringBuffer
eventDesc
=
new
StringBuffer(desc);
eventDesc.append("小區"+cell.getCellName()).append("[").append(
cell.getCellId()).append("]");
record(eventDesc.toString(),
null);
}
public
void
record(String
eventDesc,
String
eventOrigin)
{
CbsEvent
event
=
new
CbsEvent();
event.setEventDesc(userName
+
"
"
+
eventDesc);
event.setEventOrigin(eventOrigin);
event.setStartTime(new
Timestamp(System.currentTimeMillis()));
cbsEventManager.save(event);
}
public
void
setUserName(String
userName)
{
this.userName
=
userName;
}
public
static
String[]
getDeleteEntitysFireEven
t()
{
return
deleteEntitysFireEvent;
}
public
static
String[]
getSaveEntitysFireEvent()
{
return
saveEntitysFireEvent;
}
public
static
String[]
getUpdateEntitysFireEven
t()
{
return
updateEntitysFireEvent;
}
public
static
String
getPrefixPackageName()
{
return
prefixPackageName;
}
public
static
void
setPrefixPackageName(String
prefixPackageName)
{
EventRecord.prefixPackageName
=
prefixPackageName;
}
public
static
String
getPrefixMethodName()
{
return
prefixMethodName;
}
public
static
String
getDeleteInfo()
{
return
deleteInfo;
}
public
static
String
getSaveInfo()
{
return
saveInfo;
}
public
static
String
getUpdateInfo()
{
return
updateInfo;
}
}
其中EventRecord 在spring中的配置為：
Java代碼
<bean
id="eventRecord"
class="com.creawor.cbsms.event.EventRecord"
scope="session"
autowire="byName"/>
EventRecord 為session范圍可以使欄位userName記錄每次登錄人員的姓名
具體在每次登錄後從spring容器中得到EventRecord然後set其userName即可！
最後一步要想讓session范圍生效還要在web.xml中添加配置：
Java代碼
<web-app>
...
<listener>
<listener-class>org.springframework.web.context.request.RequestContextListener</listener-class>
</listener>
...
</web-app>
這樣如果想要記錄一個業務bean增刪改的操作只需在EventRecord中設置saveEntitysFireEvent，deleteEntitysFireEvent，updateEntitysFireEvent屬性即可，同樣也可使用配置文件配置，這樣都可以使日誌和事件的記錄變得很簡單！
❷ spring boot怎麼配置攔截器
第一種模式BIOS：在將Secure Boot設置為Enabled後，Secure Boot Status依然為關閉狀態。步驟1：在機器重啟至bios界面時，不停敲擊「F2」鍵或「Del」鍵進入BIOS，不同主板按鍵不一樣，大家可以注意bios下方一般有按鍵提示。進入bios之後，選擇Security選項，選擇Reset to Setup Mode並敲回車，選擇YES並按下「回車」鍵；步驟2：選擇Restore Factory Keys並敲回車，選擇YES並按下「回車」鍵；步驟3：按F9或FN+F9恢復BIOS默認設置；步驟4：按F10或FN+F10保存退出，並不停敲擊「F2」鍵或「Fn+F2」鍵進入BIOS。檢查Secure Boot Status，此時應已經變為Enabled狀態，保存退出即可；步驟5：進入系統後就會發現桌面右下角顯示的「SecureBoot未正確配置」提示消息消失了。
❸ 什麼是攔截器，如何配置攔截器，如何使用攔截器
需在web.xml文件中配置<filter>標簽，這個標簽就是用作攔截器的，具體的配置如下：
<filter> --- 配置過濾器
<filter-name>FirstFilter</filter-name>
---為過濾器起一個名字
<filter-class>com.itheima.filter.FirstFilter</filter-class>
---過濾器類的全路徑名
<init-param>
--- 可選的 可以配置多個 過濾器的初始化參數可以在過濾器中通過FilterConfig對象來獲取
<param-name>name1</param-name>
<param-value>value1</param-value>
</init-param>
</filter>
<filter-mapping>
--- 配置過濾器的攔截路徑 ,一個<Filter>可以配置多個<filter-mappint>
<filter-name>FirstFilter</filter-name>
---為哪個過濾器進行配置
<url-pattern>/*</url-pattern>
--- 攔截哪個路徑 其中url-pattern的寫法和學習Serlvet時的url-pattern的寫法相同 這個url-pattern可以配置多個
<servlet-name>Demo1Servlet</servlet-name>
---攔截哪個名字的Servlet 可以配置多個
<dispatcher>REQUEST</dispatcher>
--- 配置攔截哪種類型的對資源的訪問,可選的值有REQUESTFORWARD INCLUDE ERROR,如果不配置默認只攔截REQUEST方式,如果具體配置了就攔截具體配置的方式的對資源的訪問,此標簽可以配置多個
</filter-mapping>
簡單點說就是需要配置<filter>和<filter-mapper>標簽，filter標簽里<filter-name>、<filter-class>是必須要的，filtermapper中<filter-name>、<url-pattern>是必須要的，其他標簽都是可選的
❹ spring怎麼實現aop，攔截器怎麼配置的
你指的是aop:config和mvc:interceptors的區別嗎？簡單的講他們的區別是：aop:config是針對類方法的攔截，適用於所有的java類方法的攔截，包括javase。只需要在applicationContext.xml里設置就行了。mvc:interceptors是針對web請求的攔截，與java.servlet.Filter很類似。通過設置需要攔截的url請求從而攔截請求方法。其他方面兩者都差不多。
❺ spring mvc用html5 攔截器怎麼配置
SpringMVC 中的Interceptor 攔截器也是相當重要和相當有用的，它的主要作用是攔截用戶的請求並進行相應的處理。比如通過它來進行許可權驗證，或者是來判斷用戶是否登陸，或者是像12306 那樣子判斷當前時間是否是購票時間。
1、定義Interceptor的實現類
SpringMVC 中的Interceptor 攔截請求是通過HandlerInterceptor 來實現的。在SpringMVC 中定義一個Interceptor 非常簡單，主要有兩種方式：
第一種方式是要定義的Interceptor類要實現了Spring 的HandlerInterceptor
介面，或者是這個類繼承實現了HandlerInterceptor 介面的類，比如Spring
已經提供的實現了HandlerInterceptor 介面的抽象類HandlerInterceptorAdapter ；
第二種方式是實現Spring的WebRequestInterceptor介面，或者是繼承實現了WebRequestInterceptor的類。
2、實現HandlerInterceptor介面
HandlerInterceptor 介面中定義了三個方法，我們就是通過這三個方法來對用戶的請求進行攔截處理的。
（1 ）preHandle (HttpServletRequest
request, HttpServletResponse response, Object handle)
方法，顧名思義，該方法將在請求處理之前進行調用。SpringMVC 中的Interceptor
是鏈式的調用的，在一個應用中或者說是在一個請求中可以同時存在多個Interceptor 。每個Interceptor
的調用會依據它的聲明順序依次執行，而且最先執行的都是Interceptor
中的preHandle
方法，所以可以在這個方法中進行一些前置初始化操作或者是對當前請求的一個預處理，也可以在這個方法中進行一些判斷來決定請求是否要繼續進行下去。該方法
的返回值是布爾值Boolean 類型的，當它返回為false 時，表示請求結束，後續的Interceptor 和Controller
都不會再執行；當返回值為true 時就會繼續調用下一個Interceptor 的preHandle
方法，如果已經是最後一個Interceptor 的時候就會是調用當前請求的Controller 方法。
（2 ）postHandle (HttpServletRequest
request, HttpServletResponse response, Object handle, ModelAndView
modelAndView) 方法，由preHandle 方法的解釋我們知道這個方法包括後面要說到的afterCompletion
方法都只能是在當前所屬的Interceptor 的preHandle 方法的返回值為true 時才能被調用。postHandle
方法，顧名思義就是在當前請求進行處理之後，也就是Controller 方法調用之後執行，但是它會在DispatcherServlet
進行視圖返回渲染之前被調用，所以我們可以在這個方法中對Controller 處理之後的ModelAndView
對象進行操作。postHandle 方法被調用的方向跟preHandle 是相反的，也就是說先聲明的Interceptor
的postHandle 方法反而會後執行，這和Struts2 裡面的Interceptor 的執行過程有點類型。Struts2
裡面的Interceptor
的執行過程也是鏈式的，只是在Struts2 裡面需要手動調用ActionInvocation 的invoke
方法來觸發對下一個Interceptor 或者是Action 的調用，然後每一個Interceptor 中在invoke
方法調用之前的內容都是按照聲明順序執行的，而invoke 方法之後的內容就是反向的。
（3
）afterCompletion(HttpServletRequest request, HttpServletResponse
response, Object handle, Exception ex) 方法，該方法也是需要當前對應的Interceptor
的preHandle 方法的返回值為true 時才會執行。顧名思義，該方法將在整個請求結束之後，也就是在DispatcherServlet
渲染了對應的視圖之後執行。這個方法的主要作用是用於進行資源清理工作的。
下面是一個簡單的代碼說明：
[java] view plain
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;
public class SpringMVCInterceptor implements HandlerInterceptor {
/**
* preHandle方法是進行處理器攔截用的，顧名思義，該方法將在Controller處理之前進行調用，SpringMVC中的Interceptor攔截器是鏈式的，可以同時存在
* 多個Interceptor，然後SpringMVC會根據聲明的前後順序一個接一個的執行，而且所有的Interceptor中的preHandle方法都會在
* Controller方法調用之前調用。SpringMVC的這種Interceptor鏈式結構也是可以進行中斷的，這種中斷方式是令preHandle的返
* 回值為false，當preHandle的返回值為false的時候整個請求就結束了。
*/
@Override
public boolean preHandle(HttpServletRequest request,
HttpServletResponse response, Object handler) throws Exception {
// TODO Auto-generated method stub
return false;
}
/**
* 這個方法只會在當前這個Interceptor的preHandle方法返回值為true的時候才會執行。postHandle是進行處理器攔截用的，它的執行時間是在處理器進行處理之
* 後，也就是在Controller的方法調用之後執行，但是它會在DispatcherServlet進行視圖的渲染之前執行，也就是說在這個方法中你可以對ModelAndView進行操
* 作。這個方法的鏈式結構跟正常訪問的方向是相反的，也就是說先聲明的Interceptor攔截器該方法反而會後調用，這跟Struts2裡面的攔截器的執行過程有點像，
* 只是Struts2裡面的intercept方法中要手動的調用ActionInvocation的invoke方法，Struts2中調用ActionInvocation的invoke方法就是調用下一個Interceptor
* 或者是調用action，然後要在Interceptor之前調用的內容都寫在調用invoke之前，要在Interceptor之後調用的內容都寫在調用invoke方法之後。
*/
@Override
public void postHandle(HttpServletRequest request,
HttpServletResponse response, Object handler,
ModelAndView modelAndView) throws Exception {
// TODO Auto-generated method stub
}
/**
* 該方法也是需要當前對應的Interceptor的preHandle方法的返回值為true時才會執行。該方法將在整個請求完成之後，也就是DispatcherServlet渲染了視圖執行，
* 這個方法的主要作用是用於清理資源的，當然這個方法也只能在當前這個Interceptor的preHandle方法的返回值為true時才會執行。
*/
@Override
public void afterCompletion(HttpServletRequest request,
HttpServletResponse response, Object handler, Exception ex)
throws Exception {
// TODO Auto-generated method stub
}
}
3、定義的攔截器類加到SpringMVC的攔截體系中
[html] view plain
<span style="font-size:12px;"> <mvc:interceptors>
<!-- 使用bean定義一個Interceptor，直接定義在mvc:interceptors根下面的Interceptor將攔截所有的請求 -->
<bean class="com.host.app.web.interceptor.AllInterceptor"/>
<mvc:interceptor>
<mvc:mapping path="/test/number.do"/>
<!-- 定義在mvc:interceptor下面的表示是對特定的請求才進行攔截的 -->
<bean class="com.host.app.web.interceptor.LoginInterceptor"/>
</mvc:interceptor>
</mvc:interceptors></span>
由上面的示例可以看出可以利用mvc:interceptors標簽聲明一系列的攔截器，然後它們就可以形成一個攔截器鏈，攔截器的執行順序是按聲明的先
後順序執行的，先聲明的攔截器中的preHandle方法會先執行，然而它的postHandle方法和afterCompletion方法卻會後執
行。
在mvc:interceptors標簽下聲明interceptor主要有兩種方式：
（1）直接定義一個Interceptor實現類的bean對象。使用這種方式聲明的Interceptor攔截器將會對所有的請求進行攔截。
（2）使用mvc:interceptor標簽進行聲明。使用這種方式進行聲明的Interceptor可以通過mvc:mapping子標簽來定義需要進行攔截的請求路徑。
經過上述兩步之後，定義的攔截器就會發生作用對特定的請求進行攔截了。
❻ 在SpringBoot中如何配置基礎攔截器
所有的開發之中攔截器一定是一個必須要使用的功能，利用攔截器可以更加有效的實現數據的驗證處理，而且最為幸運的是在SpringBoot之中所使用的攔截器與Spring中的攔截器完全一樣。
基礎攔截器操作
攔截器是一種AOP操作實現，那麼在AOP之中用戶一定不需要去關注攔截器的存在，用戶只需要按照自己已經習慣的處理方式進行代碼的編寫即可。
創建一個程序的控制器類：
package com.gwolf.controller;
import com.gwolf.util.controller.AbstractBaseController;
import com.gwolf.vo.Member;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.ResponseBody;
@Controller
public class MemberController extends AbstractBaseController{
@RequestMapping(value="/member_add_pre", method = RequestMethod.GET)
public String memberAddPre() {
return "member_add";
}
@RequestMapping(value="/member_add", method = RequestMethod.POST)
@ResponseBody
public Object memberAdd(Member member) {
return member;
}
}
❼ springMVC中關於攔截器的兩種配置有什麼不同
你指的是aop:config和mvc:interceptors的區別嗎看
簡單的講他們的區別是：
aop:config是針對類方法的攔截，適用於所有的java類方法的攔截，包括javase。只需要在applicationContext.xml里設置就行了。
mvc:interceptors是針對web請求的攔截，與java.servlet.Filter很類似。通過設置需要攔截的url請求從而攔截請求方法。
其他方面兩者都差不多。
❽ ssh2中如何配置攔截器
自定義攔截器
作為「框架（framework）」，可擴展性是不可或缺的，因為世上沒有放之四海而皆準的東西。雖然，Struts 2為我們提供如此豐富的攔截器實現，但是這並不意味我們失去創建自定義攔截器的能力，恰恰相反，在Struts 2自定義攔截器是相當容易的一件事。
大家在開始著手創建自定義攔截器前，切記以下原則：
攔截器必須是無狀態的，不要使用在API提供的ActionInvocation之外的任何東西。
要求攔截器是無狀態的原因是Struts 2不能保證為每一個請求或者action創建一個實例，所以如果攔截器帶有狀態，會引發並發問題。
所有的Struts 2的攔截器都直接或間接實現介面com.opensymphony.xwork2.interceptor.Interceptor。除此之外，大家可能更喜歡繼承類com.opensymphony.xwork2.interceptor.AbstractInterceptor。
以下例子演示通過繼承AbstractInterceptor，實現授權攔截器。
首先，創建授權攔截器類tutorial.AuthorizationInterceptor，代碼如下：
package tutorial;
import java.util.Map;
import com.opensymphony.xwork2.Action;
import com.opensymphony.xwork2.ActionInvocation;
import com.opensymphony.xwork2.interceptor.AbstractInterceptor;
public class AuthorizationInterceptor extends AbstractInterceptor {
@Override
public String intercept(ActionInvocation ai) throws Exception {
Map session = ai.getInvocationContext().getSession();
String role = (String) session.get( " ROLE " );
if ( null != role) {
Object o = ai.getAction();
if (o instanceof RoleAware) {
RoleAware action = (RoleAware) o;
action.setRole(role);
}
return ai.invoke();
} else {
return Action.LOGIN;
}
}
}
以上代碼相當簡單，我們通過檢查session是否存在鍵為「ROLE」的字元串，判斷用戶是否登陸。如果用戶已經登陸，將角色放到Action中，調用Action；否則，攔截直接返回Action.LOGIN欄位。為了方便將角色放入Action，我定義了介面tutorial.RoleAware，代碼如下：
package tutorial;
public interface RoleAware {
void setRole(String role);
}
接著，創建Action類tutorial.AuthorizatedAccess模擬訪問受限資源，它作用就是通過實現RoleAware獲取角色，並將其顯示到ShowUser.jsp中，代碼如下：
package tutorial;
import com.opensymphony.xwork2.ActionSupport;
public class AuthorizatedAccess extends ActionSupport implements RoleAware {
private String role;
public void setRole(String role) {
this .role = role;
}
public String getRole() {
return role;
}
@Override
public String execute() {
return SUCCESS;
}
}
以下是ShowUser.jsp的代碼：
<% @ page contentType = " text/html; charset=UTF-8 " %>
<% @taglib prefix = " s " uri = " /struts-tags " %>
< html >
< head >
< title > Authorizated User </ title >
</ head >
< body >
< h1 > Your role is: < s:property value ="role" /></ h1 >
</ body >
</ html >
然後，創建tutorial.Roles初始化角色列表，代碼如下：
package tutorial;
import java.util.Hashtable;
import java.util.Map;
public class Roles {
public Map < String, String > getRoles() {
Map < String, String > roles = new Hashtable < String, String > ( 2 );
roles.put( " EMPLOYEE " , " Employee " );
roles.put( " MANAGER " , " Manager " );
return roles;
}
}
接下來，新建Login.jsp實例化tutorial.Roles，並將其roles屬性賦予<s:radio>標志，代碼如下：
<% @ page contentType = " text/html; charset=UTF-8 " %>
<% @taglib prefix = " s " uri = " /struts-tags " %>
< html >
< head >
< title > Login </ title >
</ head >
< body >
< h1 > Login </ h1 >
Please select a role below:
< s:bean id ="roles" name ="tutorial.Roles" />
< s:form action ="Login" >
< s:radio list ="#roles.roles" value ="'EMPLOYEE'" name ="role" label ="Role" />
< s:submit />
</ s:form >
</ body >
</ html >
創建Action類tutorial.Login將role放到session中，並轉到Action類tutorial.AuthorizatedAccess，代碼如下：
package tutorial;
import java.util.Map;
import org.apache.struts2.interceptor.SessionAware;
import com.opensymphony.xwork2.ActionSupport;
public class Login extends ActionSupport implements SessionAware {
private String role;
private Map session;
public String getRole() {
return role;
}
public void setRole(String role) {
this .role = role;
}
public void setSession(Map session) {
this .session = session;
}
@Override
public String execute() {
session.put( " ROLE " , role);
return SUCCESS;
}
}
最後，配置struts.xml文件，內容如下：
<! DOCTYPE struts PUBLIC
"-//Apache Software Foundation//DTD Struts Configuration 2.0//EN"
"http://struts.apache.org/dtds/struts-2.0.dtd" >
< struts >
< include file ="struts-default.xml" />
< package name ="InterceptorDemo" extends ="struts-default" >
< interceptors >
< interceptor name ="auth" class ="tutorial.AuthorizationInterceptor" />
</ interceptors >
< action name ="Timer" class ="tutorial.TimerInterceptorAction" >
< interceptor-ref name ="timer" />
< result > /Timer.jsp </ result >
</ action >
< action name ="Login" class ="tutorial.Login" >
< result type ="chain" > AuthorizatedAccess </ result >
</ action >
< action name ="AuthorizatedAccess" class ="tutorial.AuthorizatedAccess" >
< interceptor-ref name ="auth" />
< result name ="login" > /Login.jsp </ result >
< result name ="success" > /ShowRole.jsp </ result >
</ action >
</ package >
</ struts >
發布運行應用程序，在瀏覽器地址欄中輸入：http://localhost:8080/Struts2_Interceptor/AuthorizatedAccess.action。由於此時，session還沒有鍵為「ROLE」的值，所以返回Login.jsp頁面，如圖2所示：
圖2 Login.jsp
選中Employee，點擊Submit，出現圖3所示頁面：
以上是從一個Struts2的文檔上截取下來的，如何自定義攔截器，裡面還有很多關於Struts的實用技巧，需要的話我可以把文檔發給你。
❾ spring boot 怎麼配置攔截器
第一種模式BIOS：在將Secure Boot設置為Enabled後，Secure Boot Status依然為關閉狀態。步驟1：在機器重啟至bios界面時，不停敲擊「F2」鍵或「Del」鍵進入BIOS，不同主板按鍵不一樣，大家可以注意bios下方一般有按鍵提示。進入bios之後，選擇Security選項，選擇Reset to Setup Mode並敲回車，選擇YES並按下「回車」鍵；步驟2：選擇Restore Factory Keys並敲回車，選擇YES並按下「回車」鍵；步驟3：按F9或FN+F9恢復BIOS默認設置；步驟4：按F10或FN+F10保存退出，並不停敲擊「F2」鍵或「Fn+F2」鍵進入BIOS。檢查Secure Boot Status，此時應已經變為Enabled狀態，保存退出即可；步驟5：進入系統後就會發現桌面右下角顯示的「SecureBoot未正確配置」提示消息消失了