Java Structs框架原理案例详解

什么是Struts框架

Struts框架是一种流行的Java Web应用程序框架，Struts采用MVC（Model-View-Controller）架构模式，将应用程序的数据（Model），用户界面（View）和控制逻辑（Controller）清晰地分离开，以便维护和扩展应用程序。

Struts框架包含许多重要的组件，包括Action、Interceptor、Result、ValueStack、Tag等。

Struts框架的核心原理

Struts框架的核心原理是拦截器（Interceptor）。拦截器是一种可扩展的机制，在处理请求之前或之后，将适当的代码注入到请求处理流程中。

Struts框架中的请求处理过程如下：

1. 用户发送HTTP请求，其中包含一个Action名称或URL；
2. Struts根据Action名称或URL查找适当的Action；
3. Struts将该Action与配置文件中定义的Interceptors相关联，同时创建ActionContext和ValueStack对象；
4. Struts调用Interceptors处理ActionContext和ValueStack对象，这一过程中可以添加、删除或修改Action的属性；
5. Struts调用Action的方法，处理请求；
6. Struts将Action的结果传递给Result；
7. Struts调用Result，生成响应。

Struts框架的实例

下面是一个简单的Struts框架实例，包括一个Action、一个Interceptor、一个Result和一个配置文件。

Action

public class MyAction extends ActionSupport {
    private String message;

    @Override
    public String execute() throws Exception {
        setMessage("Hello, Struts!");
        return SUCCESS;
    }

    public String getMessage() {
        return message;
    }

    public void setMessage(String message) {
        this.message = message;
    }

}

Interceptor

public class MyInterceptor implements Interceptor {
    public void init() {
        System.out.println("My Interceptor initialized.");
    }

    public void destroy() {
        System.out.println("My Interceptor destroyed.");
    }

    public String intercept(ActionInvocation invocation) throws Exception {
        System.out.println("My Interceptor pre-processing.");
        String result = invocation.invoke();
        System.out.println("My Interceptor post-processing.");
        return result;
    }
}

Result

public class MyResult implements Result {
    private String resultValue;

    public String getResultValue() {
        return resultValue;
    }

    public void setResultValue(String resultValue) {
        this.resultValue = resultValue;
    }

    public void execute(ActionInvocation invocation) throws Exception {
        System.out.println("My Result executing.");
        String message = ((MyAction) invocation.getAction()).getMessage();
        setResultValue(message);
        HttpServletResponse response = ServletActionContext.getResponse();
        response.setContentType("text/html;charset=utf-8");
        response.getWriter().println(message);
    }

}

配置文件

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE struts PUBLIC "-//Apache Software Foundation//DTD Struts Configuration 2.0//EN" "http://struts.apache.org/dtds/struts-2.0.dtd">

<struts>
    <constant name="struts.enable.DynamicMethodInvocation" value="false" />
    <constant name="struts.devMode" value="false" />

    <package name="default" extends="struts-default">
        <interceptors>
            <interceptor name="myInterceptor" class="com.example.MyInterceptor"></interceptor>
        </interceptors>
        <default-interceptor-ref name="myInterceptor" />
        <action name="myAction" class="com.example.MyAction">
            <result type="com.example.MyResult"></result>
        </action>
    </package>
</struts>

在这个示例中，我们创建了一个名为"myAction"的Action，该Action会被映射到配置文件中的"/myAction" URL。Action中的execute()方法返回一个"SUCCESS"字符串，这意味着Struts应该将请求的处理交给一个Result对象。

MyResult对象是一个自定义的Result，它在Action执行成功后将数据写回HTTP响应中。MyInterceptor对象是一个自定义的Interceptor，它会在整个请求处理流程中注入一些逻辑。

另一个Struts框架的示例

下面是另一个Struts框架的示例，包括一个Action、一个Interceptor和一个配置文件。

Action

public class LoginAction extends ActionSupport {

    private String username;
    private String password;

    @Override
    public String execute() throws Exception {
        if ("admin".equals(getUsername()) && "admin".equals(getPassword())) {
            return SUCCESS;
        } else {
            return ERROR;
        }
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getUsername() {
        return username;
    }

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

    public String getPassword() {
        return password;
    }

}

Interceptor

public class AuthenticationInterceptor implements Interceptor {
    public void init() {
        System.out.println("AuthenticationInterceptor initialized.");
    }

    public void destroy() {
        System.out.println("AuthenticationInterceptor destroyed.");
    }

    public String intercept(ActionInvocation invocation) throws Exception {
        ActionContext context = invocation.getInvocationContext();
        Map<String, Object> session = context.getSession();

        if (session.get("username") == null) {
            return "login";
        } else {
            return invocation.invoke();
        }
    }
}

配置文件

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE struts PUBLIC "-//Apache Software Foundation//DTD Struts Configuration 2.0//EN" "http://struts.apache.org/dtds/struts-2.0.dtd">

<struts>
    <constant name="struts.enable.DynamicMethodInvocation" value="false" />
    <constant name="struts.devMode" value="false" />

    <package name="default" extends="struts-default">
        <interceptors>
            <interceptor name="authenticationInterceptor" class="com.example.AuthenticationInterceptor"></interceptor>
        </interceptors>
        <default-interceptor-ref name="authenticationInterceptor" />
        <action name="login" class="com.example.LoginAction">
            <result name="success">/success.jsp</result>
            <result name="error">/error.jsp</result>
            <result name="login">/login.jsp</result>
        </action>
    </package>
</struts>

在这个示例中，我们创建了一个名为"login"的Action，它将登录用户的用户名和密码存储在会话中。在配置文件中的AuthenticationInterceptor拦截器会验证用户是否已登录。如果用户已登录，则拦截器将传递请求到Action；否则，拦截器将重定向到"/login"视图。

以上就是Struts框架的核心原理及两个实例的详细介绍。