浅谈struts2

一 对struts2的简介和理解

1. 什么是Struts2

    Struts2是一个基于MVC设计模式的Web应用框架，它本质上相当于一个servlet，在MVC设计模式中，Struts2作为控制器(Controller)来建立模型与视图的数据交互。

  2.为什么要学习struts2？

    （1）.简化开发，所有的框架都是为了简化开发而发明的。

    （2）.对于软件工程而言最重要的思想必定是高内聚，低耦合。降低了视图层和模型的耦合

 3.struts2的核心思想

          核心思想：1.拦截器的使用

                            2.ognl表达式

                            3.值栈

 4.struts2的执行流程

     

 

 简单流程：  

        1.通过浏览器向服务器发送一个请求.

        2.会被 StrutsPrepareAndExecuteFilter 拦截到。只有配置这个strtus2才能起作用

        3.调用框架中的默认拦截器进行拦截

        4.执行相应的action操作

        5.通过action跳转到相对的视图中

5.熟悉一个配置文件。

          1.一个框架配置文件重点掌握： default.properties 

           2. struts.xml 配置

            package配置

                    属性：

                    name   ： 作用:定义一个包的名称，它必须唯一。                              

                    namespase ：与action中的name一起确定访问路径

                    extends    ：继承包

                    abstruct ：它代表当前包是一个抽象的，主要是用于被继承  

            action配置

                    name ：该名称和namespse组合成为action的访问路径

                    class ：action的全路径

                    method ：在action中调用的方法

             result配置

            name:在action中返回的名称相同

               tape: 跳转方式

二、Action的创建方法（3种）

1. 创建一个pojo
2. 实现一个接口Action
3. 继承ActionSupport

三、struts2的数据封装

•        属性驱动

     在action中直接给出get、set方法这种比较简单也比较常用

•         模型驱动       

1.  让Action实现modelDriven
2. new出对象
3. 重写getmodel方法（将模型返回）

                 两种对比：属性驱动比较方便，但是在action中写出来比较乱。模型驱动开发中比较常用，但是只能对于一个模型数据进行封装。用起来比较麻烦

四、对于值栈的理解

   1. 获取struts2的Servlet API

      在action中获取request的方式有两种

•     ServletActionContext获取              

 HttpServletRequest request = ServletActionContext.getRequest();
ServletActionContext.getResponse().setCharacterEncoding("utf-8");
String username = request.getParameter("username");

• 注入方式 

ServletRequestAware, 实现这个接口可以获取HttpServletRequest
ServletResponseAware ,实现这个接口可以获取HttpServletResponse
ServletContextAware 实现这个接口可以获取ServletContext

 2.ognl表达式（感觉鸡肋，有el表达式使用）

        1.支持静态

        2.支持访问

3.值栈

         这里的valueStack和我们之前学习web的域很像功能也是一样的

        action中产生的数据携带到页面上，也就是说valueStack它就是一个容器。

  1.研究值栈的结构：     

  在struts2中valueStack是一个接口，所以我们需要找到他的实现类，我们看到ObnlValueStack实现了ValueStack.

 public abstract Map<Object, Object> getExprOverrides();/**
   
    public abstract CompoundRoot getRoot();
    public abstract CompoundRoot getRoot();

一张图看懂

        

2.这四点很重要

        1.CompoundRoot:它就是一个ArrayList

   2.它主要存储的是action的相关数据

        3.Map<String,Object> context:就是一个Map

          4.通过ognl表达式来获取valueStack中数据，没有使用#就会从CompoundRoot中获取数据，如果使用#来获取， 这时就会从context中来获取.

3.向ValueStack存数据

        1.主要向root存

        2.手动存 set,自动存 push

        3.前台获取数据 el，ognl

       问题：为什么el可以从valuestack数据？

          答：struts2对request进行了增强，重写了getAttribute方法，域中查不到就去值栈中找

    

 4.手写过滤器

        1.实现接口interceptor

        2.配置文件声明<interceptor name="" class=""></interceptor>名称，全路径名

        3.自定义的Interceptor,那么默认的defaultStack就不会在导入，需要手动导入。

太困了先写在这里。下回写注解开发和遇到的一些bug

package me.zhengjie;

import cn.hutool.core.builder.EqualsBuilder;
import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.util.ObjectUtil;
import cn.hutool.core.util.ReflectUtil;
import com.alibaba.fastjson.JSON;
import lombok.extern.slf4j.Slf4j;
import me.zhengjie.modules.quartz.domain.QuartzJob;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
@Slf4j
public class ListCompareUtils {

    /**
     * @param newData    新数据
     * @param oldData    旧数据
     * @param notCompare 不需要判断修改的字段名(null时,判断所有字段)
     * @param only       新旧数据比对的字段名(唯一字段值所在字段)
     * @param <T>
     * @return
     */
    public static <T> Map<String, List<T>> getListCompare(List<T> newData, List<T> oldData, String[] notCompare, String[] only) {
        Map<String, List<T>> map = new HashMap();
        List<T> updateList = new ArrayList<>();
        for (int i = newData.size() - 1; i >= 0; i--) {
            for (int j = oldData.size() - 1; j >= 0; j--) {
                T t = newData.get(i);
                T t1 = oldData.get(j);
                if (judgeOnly(only, t, t1)) {
                    if (!EqualsBuilder.reflectionEquals(t, t1, notCompare)) {
                        //当有修改时,加入updateList中,跳出旧oldData,继续遍历newData;
                        updateList.add(t);
                    }
                    newData.remove(i);
                    oldData.remove(j);
                    break;
                }
            }
        }
        log.info("insertList ->{},updateList ->{},deleteList->{}", newData.size(), updateList.size(), oldData.size());
        map.put("insertList", newData);
        map.put("updateList", updateList);
        map.put("deleteList", oldData);
        return map;
    }

    /**
     * 判断是否满足比较条件
     *
     * @param only 需要满足相等的字段名
     * @param one  对象1
     * @param two  对象2
     * @param <T>
     * @return
     */
    private static <T> boolean judgeOnly(String[] only, T one, T two) {
        for (String onlyStr : only) {
            Object onlyValue = ReflectUtil.getFieldValue(one, onlyStr);
            Object onlyValue1 = ReflectUtil.getFieldValue(two, onlyStr);
            if ((!ObjectUtil.isBasicType(onlyValue) && !(onlyValue instanceof String))
                    || (!ObjectUtil.isBasicType(onlyValue1) && !(onlyValue1 instanceof String))
                    || !ObjectUtil.equal(onlyValue, onlyValue1)) {
                return false;
            }
        }
        return true;
    }

    public static void main(String[] args) {
        // 缓存锁不可并发执行
        List<QuartzJob> value1 = new ArrayList<>();
        List<QuartzJob> value2 = new ArrayList<>();
        for (int i = 0; i < 20; i++) {
            QuartzJob pdaExecutionDrug = new QuartzJob();
            pdaExecutionDrug.setId(Long.parseLong(i+""));
            pdaExecutionDrug.setCronExpression("----cron"+i);
            value1.add(pdaExecutionDrug);
        }
        QuartzJob quartzJob = value1.get(2);
        quartzJob.setCronExpression("99999999");
        value1.add(quartzJob);

        QuartzJob quartzJob1 = value1.get(4);
        quartzJob1.setIsPause(true);
        value1.add(quartzJob1);
        for (int i = 0; i < 25; i++) {
            QuartzJob pdaExecutionDrug = new QuartzJob();
            pdaExecutionDrug.setId(Long.parseLong(i+""));
            pdaExecutionDrug.setCronExpression("----cron"+i);
            value2.add(pdaExecutionDrug);
        }
        Map<String, List<QuartzJob>> listCompare = getListCompare(CollUtil.newArrayList(value1), CollUtil.newArrayList(value2),
                new String[]{"cronExpression","beanName","methodName","isPause"}, new String[]{"id"});
        System.out.println(JSON.toJSONString(listCompare));

    }
}