JavaEE第四次实验

实验四 Struts2的工作流程——登录用户的高级功能一、基础实验——拦截器与过滤器（一）实验目的

掌握Struts2自定义拦截器的基本开发步骤和配置方法；
掌握Struts2自定义过滤器的基本开发步骤和配置方法；
理解拦截器和过滤器的特点和区别；
了解Struts2默认拦截器栈中包含的主要拦截功能；
深入理解Struts2的工作原理和基本工作过程

（二）基本知识与原理

Struts2的控制器主要由三个层次组成，分别时过滤器、拦截器和业务控制器Action；
过滤器是Struts2 控制器的最前端控制器，过滤器的使用需要在web.xml 中进行配置；FilterDispatcher 是Struts2 应用中必须配置使用的过滤器，该过滤器的主要功能包括执行Action、清空ActionContext 对象等；
拦截器是Struts2 中第二个层次的控制器，能够在Action 执行前后完成一些通用功能；
Struts2 内建了大量拦截器，这些拦截器以name-class 对的形式配置在struts-default.xml 文件中，如果struts.xml 中定义的package 继承了Struts2 默认的struts-default 包，便可以直接使用默认拦截器栈defaultStack；
Struts2 也允许自定义拦截器，自定义拦截器类须实现Interceptor 接口，并覆盖接口中的intercept 方法用于实现拦截器的主要功能；自定义拦截器须在struts.xml 中进行配置才能使用；
若在struts.xml 中为Action 指定了一个拦截器，则默认拦截器栈defaultStack将会失效，为了继续使用默认拦截器，必须将其进行显式地配置。

（三）实验内容及步骤

新建工程struts2_prij3，并导入Struts2的8个核心包

新建login.jsp页面，作为用户登录的视图；新建loginSuccess.jsp页面，作为登录成功的视图，重用实验三中页面代码；

#login.jsp
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<%@ taglib prefix="s" uri="/struts-tags"%>


    登录

#loginSuccess.jsp
<%@ taglib prefix="s" uri="/struts-tags" %>
<%--
  Created by IntelliJ IDEA.
  User: yiyi
  Date: 2021/10/11
  Time: 20:05
  To change this template use File | Settings | File Templates.
--%>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>


    登录成功


本站访问次数为：





        
    
            编号 名称 说明 单价 数量

新建cn.edu.zjut.bean包，创建UserBean.java，用于记录用户信息（重用实验三代码）

package cn.edu.zjut.bean;

import java.util.Date;

public class UserBean {
    private String account="";
    private String password="";
    private String repassword="";
    private String name="";
    private String sex="";
    private Date birthday;
    private String address="";
    private String phone="";
    private String email="";

    public String getAccount() {
        return account;
    }

    public void setAccount(String account) {
        this.account = account;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public String getRepassword() {
        return repassword;
    }

    public void setRepassword(String repassword) {
        this.repassword = repassword;
    }

    public String getName() {
        return name;
    }

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

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    public Date getBirthday() {
        return birthday;
    }

    public void setBirthday(Date birthday) {
        this.birthday = birthday;
    }

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }

    public String getPhone() {
        return phone;
    }

    public void setPhone(String phone) {
        this.phone = phone;
    }

    public String getEmail() {
        return email;
    }

    public void setEmail(String email) {
        this.email = email;
    }
}

新建cn.edu.zjut.service包，并创建UserService.java，用于实现登录逻辑和注册逻辑（重用实验三代码）

package cn.edu.zjut.serviece;

import cn.edu.zjut.bean.UserBean;

public class UserService {
    public boolean login(UserBean loginUser){
        if(loginUser.getAccount().equals(loginUser.getPassword())){
            return true;
        }
        return false;
    }
    public boolean register(UserBean registerUser){
        if(registerUser.getAccount().equals(registerUser.getPassword()) && registerUser.getPassword().equals(registerUser.getRepassword()) && !registerUser.getAccount().equals("")){
            return true;
        }
        return false;
    }
}

新建cn.edu.zjut.action包，并创建UserAction.java，定义login()方法用于调用登录逻辑（重用实验三代码）

package cn.edu.zjut.action;

import cn.edu.zjut.bean.UserBean;
import cn.edu.zjut.serviece.UserService;
import com.opensymphony.xwork2.ActionContext;
import com.opensymphony.xwork2.ActionSupport;
import org.apache.struts2.ServletActionContext;
import org.apache.struts2.interceptor.*;
import org.apache.struts2.util.ServletContextAware;

import javax.servlet.ServletContext;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;
import java.util.Map;
//implements RequestAware, SessionAware, ApplicationAware
public class UserAction extends ActionSupport {
    private UserBean loginUser;
    private Integer count=0;
    private HttpServletRequest request;
    private HttpServletResponse response;
    private ServletContext application;
    public UserAction(){
        System.out.println("创建了一个UserAction类对象。");
    }

    public Integer getCount() {
        return count;
    }

    public UserBean getLoginUser(){
        return loginUser;
    }
    public void setLoginUser(UserBean loginUser){
        this.loginUser = loginUser;
    }
        public String login(){
        count++;
        UserService userService = new UserService();
        if(userService.login(loginUser)){
            this.addActionMessage(this.getText("login,success"));
            return "loginsuccess";
        }
        else {
            this.addActionError(this.getText("login.error"));
            return "loginfail";
        }
    }
    //ActionContext方式获取请求、会话和上下文对象
//    private Map request, session, application;
//    public String login(){
//        //获取ActionContext对象
//        ActionContext ctx = ActionContext.getContext();
//        //获取请求、会话和上下文相关联的Map对象
//        request = (Map)ctx.get("request");
//        session = (Map)ctx.getSession();
//        application = (Map)ctx.getApplication();
//        //访问applicationn范围的属性值
//        Integer counter = (Integer) application.get("counter");
//        if(counter == null){
//            counter = 1;
//        }
//        else{
//            counter += 1;
//        }
//        application.put("counter", counter);
//        UserService userService = new UserService();
//        if(userService.login(loginUser)){
//            //设置session范围属性
//            session.put("user", loginUser.getAccount());
//            //设置request范围属性
//            request.put("tip", "您已登录成功");
//            return "loginsuccess";
//        }
//        else{
//            return "loginfail";
//        }
//    }
    //接口方式实现
//    private Map request, session, application;
//    public void setRequest(Map request){
//        this.request = request;
//    }
//    public void setSession(Map session){
//        this.session = session;
//    }
//    public void setApplication(Map application){
//        this.application = application;
//    }
//    public String login(){
//        Integer counter = (Integer) application.get("counter");
//        if(counter == null){
//            counter = 1;
//        }
//        else{
//            counter += 1;
//        }
//        application.put("counter", counter);
//        UserService userService = new UserService();
//        if(userService.login(loginUser)){
//            session.put("user", loginUser.getAccount());
//            request.put("tip", "您已登录成功");
//            return "loginsuccess";
//        }
//        else{
//            return "loginfail";
//        }
//    }
    //ServletContextAware、ServletRequestAware、ServletResponseAware直接访问ServletAPI
//    public void setServletRequest(HttpServletRequest request){
//        this.request = request;
//    }
//    public void setServletContext(ServletContext application){
//        this.application = application;
//    }
//    public void setServletResponse(HttpServletResponse response) {
//        this.response = response;
//    }
//    public String login(){
//        Integer counter = (Integer) application.getAttribute("counter");
//        if(counter == null){
//            counter = 1;
//        }
//        else{
//            counter += 1;
//        }
//        application.setAttribute("counter", counter);
//        UserService userService = new UserService();
//        if(userService.login(loginUser)){
//            HttpSession session = request.getSession();
//            session.setAttribute("user", loginUser.getAccount());
//            request.setAttribute("tip", "您已登录成功");
//            return "loginsuccess";
//        }
//        else{
//            return "loginfail";
//        }
//    }
    //ServletActionContext工具类直接访问Servlet API
//    public String login(){
//        HttpServletRequest request = ServletActionContext.getRequest();
//        HttpServletResponse response = ServletActionContext.getResponse();
//        ServletContext application = ServletActionContext.getServletContext();
//        HttpSession session = request.getSession();
//        Integer counter = (Integer) application.getAttribute("counter");
//        if(counter == null){
//            counter = 1;
//        }
//        else{
//            counter += 1;
//        }
//        application.setAttribute("counter", counter);
//        UserService userService = new UserService();
//        if(userService.login(loginUser)){
//            session.setAttribute("user", loginUser.getAccount());
//            request.setAttribute("tip", "您已登录成功");
//            ShoppingCart shoppingCart = new ShoppingCart();
//            session.setAttribute("shoppingcart", shoppingCart);
//            return "loginsuccess";
//        }
//        else{
//            return "loginfail";
//        }
//    }
    public String register(){
        UserService userService = new UserService();
        if(userService.register(loginUser)){
            return "registersuccess";
        }
        return "registerfail";
    }
    public void validateLogin(){
        String account = loginUser.getAccount();
        String pwd = loginUser.getPassword();
        if(account == null || account.equals("")){
            this.addFieldError("loginUser.account", this.getText("login.account.null"));
        }
        if(pwd == null || account.equals("")){
            this.addFieldError("loginUser.password", this.getText("login.password.null"));
        }
    }
    public void validateRegister(){
        String email = loginUser.getEmail();
        String pwd = loginUser.getPassword();
        String repwd = loginUser.getRepassword();
        if(!email.contains("@")){
            this.addFieldError("loginUser.email", this.getText("register.email"));
        }
        if(!pwd.equals(repwd)){
            this.addFieldError("loginUser.repassword", this.getText("register.repassword"));
        }
    }
}

在cn.edu.zjut.bean中创建Item.java，用于获取所有商品信息（重用实验三代码）

package cn.edu.zjut.bean;

public class Item {
    private String itemID;
    private String name;
    private String description;
    private double cost;

    public Item() {
    }

    public Item(String itemID, String name, String description, double cost) {
        this.itemID = itemID;
        this.name = name;
        this.description = description;
        this.cost = cost;
    }

    public String getItemID() {
        return itemID;
    }

    public void setItemID(String itemID) {
        this.itemID = itemID;
    }

    public String getName() {
        return name;
    }

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

    public String getDescription() {
        return description;
    }

    public void setDescription(String description) {
        this.description = description;
    }

    public double getCost() {
        return cost;
    }

    public void setCost(double cost) {
        this.cost = cost;
    }
}

在cn.edu.zjut.service中创建ItemService.java，用于获取所有商品信息，为简化操作，将商品信息直接写入代码中

package cn.edu.zjut.serviece;

import cn.edu.zjut.bean.Item;

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

public class ItemService {
    private List items;
    public ItemService(){
        this.items = new ArrayList();
        items.add(new Item("book001", "JAVAEE 技术实验指导教程",
                "WEB 程序设计知识回顾、" + "轻量级JAVAEE 应用框架、"
                        + "企业级EJB 组件编程技术、" + "JAVAEE 综合应用开发.", 19.95));
        items.add(new Item("book002", "JAVAEE技术",
                "Struts框架、Hibernate框架、Spring框架" + "会话Bean、实体Bean、消息驱动", 29.95 ));
    }
    public List getAllItems(){
        return items;
    }
}

在cn.edu.zjut.action中创建ItemAction.java，定义execute()方法用于调用“获取所有商品信息”逻辑

package cn.edu.zjut.action;

import cn.edu.zjut.service.ItemService;
import com.opensymphony.xwork2.ActionSupport;
import org.apache.struts2.interceptor.ApplicationAware;
import org.apache.struts2.interceptor.RequestAware;
import org.apache.struts2.interceptor.SessionAware;

import java.util.List;
import java.util.Map;

public class ItemAction extends ActionSupport implements RequestAware, SessionAware, ApplicationAware {
    private List items;
    private Map request, session, application;
    public List getItems() {
        return items;
    }

    public void setItems(List items) {
        this.items = items;
    }

    public String getAllItems() {
        ItemService itemServ = new ItemService();
        items = itemServ.getAllItems();
        session.put("items", items);
        System.out.println("ItemAction excuted!");
        return "success";
    }

    @Override
    public void setApplication(Map map) {
        this.application = map;
    }

    @Override
    public void setRequest(Map map) {
        this.request = map;
    }

    @Override
    public void setSession(Map map) {
        this.session = map;
    }
}

在struts-prj3中创建itemList.jsp页面，作为显示所有商品信息的视图

<%@ page contentType="text/html;charset=UTF-8" language="java" %>


    Title


商品列表

        
    
            编号 书名 说明 单价

修改loginSuccess.jsp页面，作为登录成功的视图，并在视图中增加超链接，用于查看所有商品信息。
```
查看所有商品信息
```

在struts.xml中配置Action并设置页面导航


    
    
    
        
        
            /loginSuccess.jsp
            /login.jsp
            /login.jsp
        
        
            /itemList.jsp

编译Web应用的web.xml文件，增加Struts2核心Filter配置



    
        struts2
        org.apache.struts2.dispatcher.FilterDispatcher
    
    
        struts2
        /*

部署Tomcat服务器，访问login.jsp成功登录后查看所有商品信息

新建cn.edu.zjut.interceptors包，创建拦截器AuthorityInterceptor.java用于实现用户权限控制功能，使得只有登录用户才有查看所有商品信息的权限

package cn.edu.zjut.intercepors;

import com.opensymphony.xwork2.Action;
import com.opensymphony.xwork2.ActionContext;
import com.opensymphony.xwork2.ActionInvocation;
import com.opensymphony.xwork2.interceptor.AbstractInterceptor;

import java.util.Map;

public class AuthorityInterceptor extends AbstractInterceptor {


    @Override
    public String intercept(ActionInvocation actionInvocation) throws Exception {
        System.out.println("Authority Interceptor excuted!");
        ActionContext ctx = actionInvocation.getInvocationContext();
        Map session = ctx.getSession();
        String user = (String)session.get("user");
        if(user != null){
            return actionInvocation.invoke();
        }
        else{
            ctx.put("tip", "您还没有登录，请输入用户名和密码登录系统");
            return Action.LOGIN;
        }
    }
}

修改UserAction.java，通过RequestAware、SessionAware、 ApplicationAware接口方式获取Session对象相关联的Map对象，当用户登录成功时，将用户名作为属性放入session范围内

    private Map request, session, application;
    public void setRequest(Map request){
        this.request = request;
    }
    public void setSession(Map session){
        this.session = session;
    }
    public void setApplication(Map application){
        this.application = application;
    }

    public String login(){
        UserService userService = new UserService();
        if(userService.login(loginUser)){
            session.put("user", loginUser.getAccount());
            request.put("tip", "您已登录成功");
            return "loginsuccess";
        }
        else{
            return "loginfail";
        }
    }

修改struts.xml文件，增加拦截器配置






    
    
    

        
            
        
        
            /loginSuccess.jsp
            /login.jsp
            /login.jsp
        
        
            /login.jsp
            /itemList.jsp

重新部署到Tomcat服务器
- 不经过登录直接通过超链接查看

- 登录后通过超链接查看

新建cn.edu.zjut.filters包，创建过滤器AccessFiler.java，用于实现JSP页面的过滤功能，使得只有登录用户才能查看除login.jsp外的其他JSP页面

package cn.edu.zjut.filters;

import javax.servlet.*;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;
import java.io.IOException;

public class AccessFilter implements Filter {

    @Override
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
        System.out.println("Access Filter executed!");
        HttpServletRequest request = (HttpServletRequest) servletRequest;
        HttpServletResponse response = (HttpServletResponse) servletResponse;
        HttpSession session = request.getSession();
        if(session.getAttribute("user") == null &&
            request.getRequestURI().indexOf("login.jsp")==-1){
            response.sendRedirect("login.jsp");
            return;
        }
        filterChain.doFilter(servletRequest, servletResponse);
    }
}

修改web.xml配置文件，增加AccessFilter配置

    
        accessFilter
        cn.edu.zjut.filters.AccessFilter
    
    
        accessFilter
        *.jsp

重新部署Tomcat服务器，首先不通过用户登录直接通过浏览器访问loginSuccess.jsp和itemList.jsp页面，然后登录后进入loginSuccess.jsp，点击超链接查看所有商品信息
- 不登录

  被重定向返回到login.jsp页面

- 登录

（四）实验总结

Interceptor接口的init（）、destory（）、intercepy（ActionInvocation inv）方法的作用
- init():初始化拦截器的回调方法
- destory():销毁拦截器之前的回调方法
- intercepy（ActionInvocation inv）:拦截器实现拦截的逻辑方法，返回值String系统跳转到该逻辑视图对应的实际视图资源
自定义拦截器配置步骤：
1. 编写实现Interceptor接口intercepy（ActionInvocation inv）方法的自定义拦截类
2. 在struts.xml中配置好拦截器跳转到的逻辑视图位置
3. 在struts.xml中为编写的拦截器类进行注册，在需要该拦截器进拦截的地方添加标签调用该拦截器
需要注意的点：
- 拦截器的注册需要放在struts中的最上方
- 拦截器需要跳转的资源xxx，则需要返回Action.XXX
default-Stack默认拦截栈的主要拦截功能：

timer:记录Action执行的时间，并作为日志输出
logger:在日志信息中输出要执行的Action信息
chain:实现Action链之间的数据传递
params:Request请求参数设置到Action对象的属性中

自定义过滤器配置步骤：
1. 编写实现Filter接口的过滤器类
2. 在web.xml文件中配置Filter的信息以及Filter的映射地址和过滤地址信息

二、提高实验——值栈与OGNL （一）实验目的

理解值栈的概念，了解值栈接口的主要方法和使用步骤；
掌握使用OGNL 获取值栈内容的方法；
掌握使用OGNL 获取session、application 等其它对象的方法。

（二）基本知识与原理

Struts API 中的com.opensymphony.xwork2.util.ValueStack 称为值栈，值栈是一个数据区域，该区域中保存了应用范围内的所有数据和Action 处理的用户请求数据；
值栈被存储在ActionContext 对象中，因此可以在任何节点访问其中的内容；
ValueStack 接口中主要方法有：Object findValue(String expr)可以通过表达式查找值栈中对应的值，void setValue(String expr, Object value)用于将对象及其表达式存到值栈中；
OGNL（Object Graphic Navigation Language），即对象图导航语言，是Struts默认的表达式语言；
OGNL 基础单位称为导航链，一个基本的链由属性名、方法调用、数组或集合元素组成；
在Struts2 中，值栈是OGNL 上下文的根对象，可以直接访问，而application、session 等其它对象不是根对象，需要使用#进行访问。

（三）实验内容及步骤

修改itemList.jsp页面，通过值栈获得属性；

修改itemList.jsp页面page指令，导入java包

<%@ page import="com.opensymphony.xwork2.util.ValueStack" %>
<%@ page import="java.util.List" %>
<%@ page import="java.util.Iterator" %>
<%@ page import="cn.edu.zjut.bean.Item" %>
<%@ taglib prefix="s" uri="/struts-tags" %>

修改itemList标签中的代码,获得值栈对象，通过值栈接口的findValue方法获得值栈中对象的值并输出

<%
    ValueStack vs = (ValueStack) request.getAttribute("struts.valueStack");
    String title = vs.findString("tableTitle");
    List itemList = (List)vs.findValue("items");
%>
商品列表

    <%
        Iterator it = itemList.iterator();
        while (it.hasNext()){
            Item item = (Item) it.next();
    %>
    
    <%
        }
    %>

    
        编号 书名 说明 单价
    

        <%=item.getItemId()%>
        <%=item.getName()%>
        <%=item.getDescription()%>
        <%=item.getCost()%>

重新访问login.jsp，登录后查看所有商品信息

编号	书名	说明	单价
<%=item.getItemId()%>	<%=item.getName()%>	<%=item.getDescription()%>	<%=item.getCost()%>

修改itemList.jsp页面，通过OGNL获得值栈内容，由于值栈是OGNL上下文根对象，所有可以直接访问

商品列表

        
    
        编号 书名 说明 单价

修改itemList.jsp页面，通过OGNL访问session对象，由于session、application等对象部署根对象，需要使用#访问

商品列表

        
    
            编号 书名 说明 单价

重新访问login.jsp，登录成功后访问所有商品信息

修改itemList.jsp页面，使用符号#过滤集合，取出价格小于20的商品和名称为“JAVAEE技术实验指导教程”的商品
```
    
        
        
    


    衬衫的价格为
    便士
```
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-MJt98iBh-1634144931705)(https://i.loli.net/2021/10/13/D6Cph4FmTJfgOnV.png)]
修改itemList.jsp,使用符号%计算OGNL表达式的值，比较使用%和不使用%的输出情况

不使用%号时，标签的属性值会被一些标签如标签理解为字符串类型，加上%{}告诉标签是OGNL表达式

（四）实验总结

ValueStack接口及其主要方法作用和开发步骤
- ValueStack贯穿整个Action的生命周期，每个Action实力都拥有一个ValueStack对象，保存了当前Action对象和其他相关对象
- findValue()方法获取ValueStack中的对象
- put()把数据放到栈顶
- setValue(“username”, String)往valueStack的根中存储数据setValue(“#username”, String)往contextMap的根中存储数据
- set()把数据存入Map，压到栈顶
- 开发步骤，从request中获取ValueStack对象，再从ValueStack里获取对象
OGNL可访问的对象：Map、Model、List
语法
- %:
  
  任何地方都可以使用，来确保ognl使用的正确性
  
  %{#name}:表示从值栈的map中取值
  %{name}:表示从值栈的对象栈中取值
  %{#request.name}:表示从request域中取值
- $一般在配置文件中使用
- #:访问request、session、application

三、拓展实验——Struts2的异常处理（一）实验目的

掌握Struts2 应用中处理异常的方式；
掌握在struts.xml 中对Action 类配置异常映射的方法。

（二）基本知识与原理

Struts2 应用中使用Action 调用Model，因此Struts2 应用中的异常在Model层抛出后，通常在Action 类中进行处理；
Action 可以直接使用try/catch 捕获异常，然后返回结果视图，跳转到相关页面处理异常；
抛出异常后，也可以不在Action 类中捕获，而使用throws 声明异常，交给Struts2 框架处理；
Struts2 允许通过struts.xml 文件来配置异常的处理，使用标签声明异常映射，指定发生该类型异常时跳转的结果视图。

（三）实验内容及步骤

新建cn.edu.zjut.exception包，并创建自定义异常类UserException.java

package cn.edu.zjut.exception;

public class UserException extends Exception{
    public UserException(){
        super();
    }
    public UserException(String msg){
        super(msg);
    }
    public UserException(String msg, Throwable cause){
        super(msg, cause);
    }
    public UserException(Throwable cause){
        super(cause);
    }
}

新建loginException.jsp页面，作为用户登录异常的视图

<%@ page contentType="text/html;charset=UTF-8" language="java" %>


    异常登录


登录异常!

修改UserService.java,在login方法中，当用户名为admin时将抛出自定义异常，当密码包含“and”或“or”时将抛出SQLException

    public boolean login(UserBean loginUser) throws Exception{
        if(loginUser.getAccount().equalsIgnoreCase("admin")){
            throw new UserException("用户名不能为admin");
        }
        if(loginUser.getPassword().toUpperCase().contains("AND") ||
        loginUser.getPassword().toUpperCase().contains("OR")){
            throw new java.sql.SQLException("密码不能包括‘and’或‘or’");
        }
        if(loginUser.getAccount().equals(loginUser.getPassword())){
            return true;
        }
        return false;
    }

修改UserAction.java，在login方法中使用try/catch捕获异常，并在捕获异常后返回结束视图，跳转到相关页面

    public String login(){
        UserService userService = new UserService();
        try{
            if(userService.login(loginUser)){
                session.put("user", loginUser.getAccount());
                request.put("tip", "您已登录成功");
                return "loginsuccess";
            }
            else{
                return "loginfail";
            }
        }catch (Exception e){
            System.out.println(e.getMessage());
            return "exception";
        }
    }

修改struts.xml文件，设置页面异常导航

        
            /loginSuccess.jsp
            /login.jsp
            /login.jsp
            /loginException.jsp

部署Tomcat服务器运行，输入admin为用户名

修改UserAction.java，在login方法中抛出异常而不捕获，将异常交给Struts2框架处理

    public String login()throws Exception{
        UserService userService = new UserService();
        try{
            if(userService.login(loginUser)){
                session.put("user", loginUser.getAccount());
                request.put("tip", "您已登录成功");
                return "loginsuccess";
            }
            else{
                return "loginfail";
            }
        }catch (Exception e){
            throw e;
        }
    }

修改struts.xml文件，使用标签完成异常配置，并通过全局和局部两种方式进行异常映射


    
    
    

        
            
        
        
            /loginException.jsp
        
        
            
        
        
            
            /loginException.jsp
            /loginSuccess.jsp
            /login.jsp
            /login.jsp

        
        
            /login.jsp
            /itemList.jsp

修改loginException.jsp页面，使用Struts2标签输出异常信息
```
登录异常!
```
部署Tomcat服务器，访问login.jsp，尝试错误登录

（四）实验总结

自定义异常类的方法和步骤：
1. 创建自定义异常类
2. 在可能产生异常的地方编写触发异常的条件并抛出异常
3. 直接处理异常或者不处理交给struts2框架处理
4. 配置全局或者局部异常配置
5. 在页面显示异常信息
标签：
- global-results全局异常
- global-exception-mappings全局异常映射组
- exception-mapping异常映射关系异常类与异常结果名，异常结果名结合result标签指定了跳转到能够视图处理

JavaEE第四次实验

Java相关栏目本月热门文章