Struts2学习笔记-基础知识

1.反射机制    在运行时可以动态获取类或者对象的信息和调用对象方法的功能
    1.java反射的三个动态特性
        1.运行时生成对象的实例
        2.运行期间调用方法
        3.运行期间更改属性
    2.通过java反射可以实现的功能
        1.在运行时判断任意一个对象所属的类
        2.在运行时构造任意一个类的对象
        3.在运行时判断任意一个类所具有的属性和方法
        4.在运行时调用任意一个类的方法
    3.java 常用的反射API
        1.Class            //反射的核心类
            1.获取Class对象                Class cls=Class.forName("cn.hb.entity.Student");
        2.Field            //类的属性
            1.返回此对象的所有的public属性        Field[] fields=cls.getFields();
            2.返回此对象声明的所有的属性        Field[] fields=cls.getDeclaredFields();
        3.Constructor        //类的构造方法
            1.返回此对象的所有的public构造函数    Constructor[] constructors=cls.getConstructors();
        4.Method        //类的方法
            1.返回此对象所有的public方法        Method[] methods=cls.getMethods();
            2.返回此对象本身声明的所有方法        Method[] methods=cls.getDeclaredMethods();
2.自定义构建基于MVC模型的框架            -Controller的设计
    1.定义Action接口
        public interface Action{
            public abstract String execute(HttpServletRequest request,HttpServletResponse response);
        }
    2.编写实现Action接口的类
        public class LoginAction implements Action{
            public String execute(HttpServletRequest request,HttpServletResponse response){
                String username=request.getParameter("username");
                String password=request.getParameter("password");
                if("admin".equals(username) && "123".equals(password)){
                    return "success";
                }else{
                    return "error";
                }
            }
        }
    3.编写Result类...对应struts.xml文件的结果集
        public class Result{
            private String name;            //result的name属性
            private String text;            //result的文本属性
            private boolean iaRedirect;        //result是否为重定向的属性
            /*
             *省略相应的get和set方法
             */    
        }
    4.编写ActionMapper类...对应元素Action的集合
        public class ActionMapper{
            private String name;            //action元素的name属性
            private String className;        //action元素对应的class属性
            private Map<String,Result> resultMap=new HashMap<String,Result>();    //action元素对应的result集合
            /*
             *省略相应的get和set方法
             */
             public Result getResult(String name){        //获得结果集合中的result元素对象
                return resultMap.get(name);
             }
             public void addResult(String name,Result result){    //添加result元素对象到集合中
                resultMap.put(name,result);
             }
        }
    5.编写ActionManager类
        public class ActionManager{
            //Actions元素对应的集合信息    --ActionMapper元素的集合
            private static Map<String,ActionMapper> actionMap=new HashMap<String,ActionMapper>();
            public ActionMapping(String[] xmlpaths){            //同事解析多个xml配置文件
                for(String string:xmlpaths){
                    init(string);
                }
            }
            //解析xml配置文件
            public void init(String xmlpath){
                InputStream inputStream=this.getClass().getResourceAsStream("/"+xmlpath);
                SAXReader reader=new SAXReader();
                //进行XML文件的头部验证
                reader.setEntityResolver(new EntityResolver() {
//                    @Override
//                    public InputSource resolveEntity(String publicId, String systemId) throws SAXException, IOException {
//                        // TODO Auto-generated method stub
//                        String pid="-//http://www.502829204.com";
//                        String sid="-http://www.123.com/Struts.dtd";
//                        if(!pid.equals(publicId)){
//                            throw new SAXException("PID文件头错误");
//                        }
//                        if(!sid.equals(systemId)){
//                            throw new SAXException("SID文件头错误");
//                        }
//                        return new InputSource(this.getClass().getResourceAsStream(systemId.substring(systemId.lastIndexOf("/"))));
//                    }
//                });
                Doucment document=reader.read(inputStream);
                Element root=document.getRootElement();
                List<Element> list=((Element)(root.elements().iterator().next())).elements();
                for(Element element:list){
                    ActionMapper am=new ActionMapper();        //新建ActionMapper实例
                    String name=element.attributeValue("name");    //获得action的name属性值
                    String className=element.attributeValue("class");//获得action的class属性值
                    am.setName(name);
                    am.setClassName(className);
                    List<Element> list2=element.elements();
                    for(Element element2:list2){
                        Result result=new Result();        //创建result元素对象
                        String name=element2.attributeValue("name");    //获得result元素的name属性
                        boolean isRedirect=Boolean.parseBoolean(elements.attributeValue("redirect"));
                        String text=element2.getText();        //获得元素的文本值
                        result.setName(name);
                        result.setText(text);
                        result.setIsRedirect(isRedirect)        //判断是否为重定向
                        am.addResult(name,result);            //将result元素加入到ActionMapper的Result集合中
                    }
                    actionMap.put(am.getName(),am);            //将ActionMapper对象加入到ActionManager的ActionMapper集合中
                }
            }
            //通过给定的name属性值.获得对应的action元素对象
            public ActionMapper getActionMapper(String name){
                if(name==null){
                    return null;
                }
                ActionMapper actionMapper=actionMap.get(name);
                if(actionMapper==null){
                    throw new Exception("该集合中的元素为空");
                }
                return actionMapper;
            }
        }
    6.编写ActionFilter类实现Filter构建触发器
        public classActionFilter implements Filter{
            private ActionManager actionManager;
            //Filter的初始化
            public void init(FilterConfig confg) throws Exception{
                String xmls=confg.getInitParameter("configuration");
                String[] xml=null;
                if(xmls==null){
                    xml=new String[]{"struts.xml"};
                }else{
                    xml=xmls.split(",");
                }
                actionManager=new Actionmanager(xml);
            }
            //Filter的触发执行
            public void doFilter(ServleRequest arg0,ServleResponse arg1,FilterChain arg2){
                HttpServletRequest request=(HttpServletRequest)arg0;
                HttpServletResponse response=(HttpServletResponse)arg1;
                String uri=request.getRequestURI();
                String name=uri.substring(uri.lastIndexOf("/")+1,uri.length()-7);
                ActionMapper actionMapper=actionManager.getActionMappper(name);
                String className=actionMapper.getClassName();
                Class cls=Class.forName(className);
                if(cls!=null){
                    Action action=(Action)cls.newIntance();
                    String type=action.execute(request,response);
                    Result result=actionMapper.getResult(type);
                    String JSPURL=result.getText();
                    if(result.isRedirect()){
                        response.sendRedirect(JSPURL);
                    }else{
                        request.getRequestDispatcher(JSPURL).forward(request,response);
                    }
                }
            }
            //Filter的销毁
            public void destroy(){
                
            }
        }
    7.编写struts.xml文件
        <mystruts>
            <actions>
                <action name="login" class="cn.struts.action.LoginAction">
                    <result name="success">success.jsp</result>
                    <result name="error" redirect="true">error.jsp</result>
                </action>
            </actions>
        </mystruts>
    8.web.xml文件的配置    --针对于Filter的配置
        <filter>
            <filter-name>ActionFilter</filter-name>
            <filter-class>cn.struts.filter.ActionFilter</filter-class>
            <init-param>
                <param-name>configuration</param-name>
                  <param-value>struts.xml</param-value>
            <init-param>
        </filter>
        <filter-mapping>
            <filter-name>ActionFilter<filter-name>
            <url-pattern>*.action</utl-pattern>
            <dispatcher>REQUEST</dispatcher>
            <dispatcher>FORWARD</dispatcher>
            <dispatcher>ERROR</dispatcher>
            <dispatcher>INCLUDE</dispatcher>
        </filter-mapping>
3.创建struts的步骤
    1.创建jsp页面
        1.Struts标签主要分为两大类    
            标签库的导入    <%@ taglib uri="/struts-tag" prefix="s" %>
            1.UI标签
                1.表单标签
                    1.<s:form></s:form>        对应相应的form值
                    2.<s:textfile></s:textfile>    文本输入框
                    3.<s:textarea></s:textarea>    文本域输入框
                    4.<s:password></s:password>    密码输入框
                    5.<s:radio></s:radio>        单选按钮
                    6.<s:checkbox></s:checkbox>    复选框
                    7.<s:submit></s:submit>        提交标签
                    8.<s:reset></s:reset>        重置标签
                    9:<s:hidden></s:hidden>        隐藏域标签
                2.非表单表单标签
                    1:<s:fielderror></s:fielderror>        //校验信息的输出
                    2.<s:property value=""></s:property>    //对指定值的输出
                3.Ajax标签
            2.通用标签
                1.条件标签
                    1.<s:if test=""></s:if>            
                    2.<s:elseif test=""></s:elseif>
                    3.<s:else test=""></s:else>
                2迭代标签
                    1.<s:iterator value="list" id="user" status="i">
                        <s:property value="username"></s:property>
                            <s:property value="#i.index"></s:property>        //获得当前遍历的索引值
                            <s:property value="#name.username"></s:property>    //获得当前遍历的对象的某个属性
                    </s:iterator>
    2.创建Action实现类
        1.struts2访问Servlet API的方式
            1.与servlet API解耦的访问方式
                1.使用ActionContext类获得Servlet API对象对应的Map对象
                    1.获得HttpServletRequest        actionContext.get("request");
                    2.获得HttpSession            actionContext.getSession();
                    3.获得ServletContext            actionContext.getApplication();
                2.使用struts2 向Action注入Servlet API的方式
                    1.注入HttpServletRequest对象        实现RequestAware接口
                    2.注入HttpSession对象            实现SessionAware接口
                    3.注入ServletContext对象        实现ApplicationAware接口
            2.与servlet API耦合的访问方式
                1.使用ServletActionContext类获得Servlet API对象对应的Map对象
                    1.获得HttpServletRequest        actionContext.getRequest();
                    2.获得HttpServletResponse        actionContext.getResponse();
                    3.获得ServletContext            actionContext.getServletContext();
                2.使用struts2 向Action注入Servlet API的方式
                    1.注入HttpServletRequest对象        实现ServletRequestAware接口
                    2.注入HttpSession对象            实现ServletSessionAware接口
                    3.注入ServletContext对象        实现ServletContextAware接口
    3.修改项目配置的web.xml
        <filter>
            <filter-name>Struts2</filter-name>
            <filter-class>org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter</filter-class>
        </filter>
        <filter-mapping>
            <filter-name>Struts2</filter-name>
            <url-pattern>/*</url-pattern>
            <dispather>REQUEST</dispatcher>
            <dispather>FORWARD</dispatcher>
        </filter-mapping>
    4.创建struts的配置文件struts.xml
        <constant name="struts.ui.theme" value="simple"></constant>    //设置用户界面主题风格.默认为XHTML
        <constant name="struts.i18n.encoding" value="UTF-8"></constant>    //设置当前struts的界面编码 默认为UTF-8
        <constant name="struts.enable.DynamicMethodInvocation" value="false"></constant>//禁止调用动态的方法
        <constant name="struts.custom.i18n.resources" value="message"></costant>
    5.编译部署并启动服务器
4.动态配置struts.xml中的action的方法
    1.在action元素中添加method的方法
        <action name="login" class="cn.struts.action.LoginAction" method="login">
            <result></result>
        </action>
        <action name="login" class="cn.struts.action.LoginAction" method="regist">
            <result></result>
        </action>
    2.在jsp页面使用动态的action标注
        <action name="user" class="cn.struts.action.LoginAction">
            <result name="success">success.jsp</result>
            <result name="error">error.jsp</result>
            <result name="input">input.jsp</result>
        </action>
    ------在JSP页面的标注
        <s:form action="user!login.action"></s:form>
    3.使用通配符来动态加载Action类
        <action name="*" class="cn.struts.action.LoginAction" method="{1}">
            <result name="success">success.jsp</result>
            <result name="error">error.jsp</result>
            <result name="input">{1}.jsp</result>
        </action>
    4.配置默认的Action    --实现无法找到Action出现的404问题
        <default-action-ref name="default"></default-action-ref>
        <action name="default">
            <result>notfound.jsp</result>
        </action>
    5.全局的结果设置
        <global-results>
            <result name="error">error.jsp</result>
            <result name="success">success.jsp</result>
        </global-results>
    6.result转发的配置 ---type="dispatcher" type="redirect" type="redirectAction"
        <action name="login" class="cn.struts.action.LoginAction">
            <result name="input">login.jsp</result>
            <result name="success" type="redirectAction">${comman}</result>
        </action>
5.拦截器和文件的上传下载
    1.拦截器中相关的一些主要对象
        1.ActionMapper        提供了在请求和Action调用请求之间的映射,ActionMapper根据请求的URL的信息.来查找是否存在对应的Action请求
        2.ActionMapping        保存了调用Action的映射信息.包括Action的name和class
        3.ActionProxy        在XWork和真正的Action之间充当代理.ActionProxy创建了ActionInvocation对象
        4.ActionInvocation    表示Action的执行状态,它保存拦截器的先后顺序,Action实例
        5.Interceptor        在请求处理之前和处理之后执行的Struts2组件
    2.拦截器的三个阶段
        1.做一些Action执行前的预处理
        2.调用ActionInvocation的invoke()方法将控制转交给后序的拦截器或者返回结果字符串并终止执行
        3.做一些Action处理后的处理
    3.基本的内置拦截器
        1.params拦截器            将请求的数据设置到Action的属性上
        2.staticParams拦截器        将action元素的param子元素的值设置到Action的属性上
        3.servletConfig拦截器        将Servlet API对象注入到Action的当中的简洁方法
        4.fileUpload拦截器        文件上传的拦截器,将文件和元素从多请求(multipart/form-data)转换为常规的请求数据
        5.validation拦截器        执行数据的校验
        6.workflow拦截器        提供数据校验错误时终止流程的功能
        7.exception拦截器        捕获异常.并将相对应的异常映射到用户指定的页面
    4.自定义拦截器
        public class MyInterceptor extends AbstractInterceptor{
                public String intercept(ActionInvocation invocation){
                    //获得Session对象
                    Map session=invocation.getInvocationContext().getSession();
                    //获得拦截器当前的转入名称
                    String url=invocation.getInvocationContext().getName();
                    if("loginuser".equals(url)){                //用此方法来拦截是否已经登录
                        return invocation.invoke();
                    }else{    
                        User user=(User)session.get("user");
                        if(user==null){
                            return Action.LOGIN;
                        }else{
                            return invocation.invoke();
                        }
                    }
                }
            }
    5.拦截器的配置和使用
        1.通过<interceptor name=""></interceptor>来定义拦截器
            <interceptors>
                //当前自定义拦截器的声明
                <intterceptor name="myInterceptor" class="cn.struts.interceptor.MyInterceptor"></interceptor>
                <interceptor-stack>
                    <interceptor-ref name="myInterceptor"></interceptor-ref>
                    <interceptor-ref name="defaultStack"></interceptor-ref>
                </interceptor-stack>
            </interceptors>
        2.通过<interceptor-ref></interceptor-ref>元素来使用拦截器
        <package>
            <action name="user" class="cn.struts.action.UserAction">
                <result name="success">success.jsp</result>
                //对自定义拦截器的引用   ---当只对自定义拦截器引用的时候还要引用默认的拦截器栈defaultStack
                <interceptor-ref name="myInterceptor"></interceptor-ref>
                <interceptor-ref name="defaultStack"></interceptor-ref>
                //对自定义拦截器栈的引用
                <interceptor-ref name="myStack"></interceptor-ref>    
            </action>
        </package>
    6.实现文件  /  多文件的上传
        1.上传的页面
            <s:form action="upload.action" method="post" enctype="multipart/form-data">
                <s:textfield name="title" label="标题"></s:textfield>
                <s:file name="upload" label="选择文件"></s:file>
                <s:submit value="点击上传"></s:submit>
            </s:form>
        2.上传的Action
            public class UploadAction extends ActionSupport{
                private String title;                    //上传文件的标题    //当有多个文件:String[] title;
                private File upload;                    //上传的文件        //当有多个文件:File[] upload
                private String uploadContentType;            //上传的文件的类型    //当有多个文件:String[] uploadContentType;
                private String uploadFileName;                //上传的文件的名称    //当有多个文件:String[] uploadFileName
                private String savePath;                //保存的路径        
                /* 省略相关的get set方法 */
                public String execute(){
                    //获得保存的路径
                    savePath=ServletActionContext.getServletContext().getRealPath(savePath);
                    byte[] bt=new byte[1024];
                    int length=0;
                    //当同时上传多个文件  可以利用循环for(int i=0;i<upload.length;i++){}
                    InputStream inputStream=new FileInputStream(upload);        //获得选定文件的输入流        //多个的时候:upload[i]
                    OutputStream outputStream=new FileOutputStream(savePath+"\\"+uploadFileName);            //多个的时候:uploadFileName[i]
                    while((length=inputStream.read(bt))!=-1){
                        outputStream.write(bt,0,length);
                    }
                    inputStream.close();
                    outputStream.close();
                    //使用FileUtils
                    FileUtils.copyFile(upload,new File(savePath+"\\"+uploadFileName));
                    return SUCCESS;
                }
            }
        3.struts.xml文件的配置
            <action name="upload" class="cn.struts.action.UploadAction">
                <param name="savePath">/upload</param>
                <interceptor-ref name="fileUpload">
                    //设置允许上传的文件的类型
                    <param name="allowedTypes">image/bmp,image/png,image/gif,image/jpeg</param>
                    //允许上传的文件的大小
                    <param name="maximumSize">1024</param>
                </interceptor-ref>
                <interceptor-ref name="defaultStack"></interceptor-ref>
                <result name="input">/global/error.jsp</result>
            </action>
    7.实现文件的下载
        1.下载页面
            <a href="download.action?fileName=a.jpg">点击下载</a>
        2.下载的Action类
            public class DownloadAction extends ActionSupport{
                private String inputPath;        //文件的下载路径
                private String fileName;        //文件的名称
                private InputStream inputStream;    //输入流
                <!--省略相关的get set方法-->
                public String execute(){
                    String path=ServletActionContext.getServletContext().getRealPath(inputPath);
                    //中文转码---解决乱码问题  --可以写在setFileName()里面
                    fileName=new String(fileName.getBytes("ISO-8859-1"),"UTF-8");
                    URLEncoder.encode(fileName, "UTF-8");
                    URLDecoder.decode(fileName, "UTF-8");
                    inputStream=new BufferedInputStream(new FileInputStream(path+"\\"+fileName));
                    //中文转码---解决乱码问题  --可以写在getFileName()里面
                    fileName=new String(fileName.getBytes("UTF-8"),"ISO-8859-1");
                    return SUCCESS;
                }
            }
        3.struts.xml文件的配置
            <action name="download" class="cn.struts.action.DownloadAction">
                <param name="inputPath">/upload</param>
                <result name="success" type="stream">
                    <param name="contentType">application/octet-stream</param>
                    <param name="inputName">inputStream</param>
                    <param name="contentDisposition">attachment;fileName="${fileName}"</param>
                    <param name="bufferSize">4096</param>
                </result>
            </action>
6.OGNL对象导航图语言                Object Graph Navigation Language
    1.OGNL在Struts框架中做的主要作用        取代页面的java脚本,简化数据的访问操作    
        1.表达式语言
        2.类型转换器
    2.自定义转换器
        1.创建自定义转换器    继承StrutsTypeConvert类...
            1.重写public Object convertFromString(Map context,String[] values,Class ToType){}
            2.重写public String convertToString(Map context,Object object){};
            public class DateConvert extends StrutsTypeConvert{
                private Date[] date={new SimpleDateFormat("yyyy-MM-dd"),
                            new SimpleDateFormat("yyyyMMdd"),
                            new SimpleDateFormat("yyyy/MM/dd"),
                            new SimpleDateFormat("yyyy年MM月dd日")};
                //将字符串转换为对象的方法
                public Object convertFromString(Map context,String[] values,Class toType){
                    String str=values[0]l
                    for(int i=0;i<date.length;i++){
                        try{
                            return date[i].parse(str);
                        }catch(Exception e){
                            continue;
                        }
                    }
                    throw new TypeConversionException();
                }
                //将对象转换位字符串的方法
                public String convertToString(Map context,Object object){
                    Date date=(Date)object;
                    return new SimpleDateFormat("yyyy-MM-dd").format(date);
                }
            }
        2.配置自定义转换器    
            1.全局转换器    src目录下创建        xwork-conversion.properties        java.util.Date=cn.struts.convert.DateConvert
            2.局部转换器    Action目录下创建    StudentAction-conversion.properties    student.date=cn.struts.convert.DateConvert
        3.处理类型转换错误
            1.前提条件    启动拦截器.继承struts-default包...<interceptor-ref name="defaultStack"></interceptor-ref>
            2.实现ValidationAware接口或者继承ActionSupport类
            3.创建input结果映射
            4.在页面使用<s:fielderror></s:fielderror>来显示错误
            5.修改所有类型的转换错误信息
                1.在struts.xml文件创建常量    <constrant name="struts.custom.i18n.resources" value="message"></constant>
                2.在src目录下创建message.properties    xwork.default.invalid.fieldvalue=字段"{0}"的属性值无效
            6.修改指定类型的转换错误信息
                1.在当前的Action的目录下面创建StudentAction.properties    invalid.fieldvalue.date=日期转换类型错误
7.Struts2的校验框架
    1.Struts2内置的校验器
        1.必填校验器            required
            1.<param name="trim">true</param>
        2.必填字符串校验器        requiredstring
            1.<param name="trim">true</param>
        3.整数校验器            int
            1.<param name="min">20</param>
            2.<param name="max">80</param>
        4.字符串长度校验器        stringlength
            1.<param name="minLength">6</param>
            2.<param name="maxLength">15</param>
        5.正则表达式校验器        regex
            1.<param name="regex">^\d{10}$</param>
        6.字段表达式校验器        fieldexpression
            1.<param name="expression">password==repassword</param>
        7.日期校验器            date
        8.双精度校验器            double    
    2.验证框架的使用步骤
        1.创建Action类继承ActionSupport类
            public class StudentAction extends ActionSupport{
                private Student student;        //学生对象
                private String repassword;        //确认密码
                //省略get set方法
                public String regist(){
                    return SUCCESS;
                }
            }
        2.在struts.xml文件中配置action
            <constant name="struts.custom.i18n.resources" value="message"></constant>
            <package>
                <default-action-ref name="default"></default-action-ref>
                <global-results>
                    <result name="success">/global/success.jsp</result>
                    <result name="error">/global/error.jsp</result>
                </global-results>
                <action name="default">
                    <result>/global/notfound.jsp</result>
                </action>
                <action name="*Student" class="cn.struts.action.StudentAction" method="{1}">
                    <result name="input">studentregist.jsp</result>
                </action>
            <package>
        3.创建jsp页面
            <s:form action="registStudent.action" method="post">
                <table>
                    <tr>
                        <td><s:text name="username"></s:text>:</td>
                        <td><s:textfield name="student.username"></s:textfield></td>
                        <td><s:fielderror fieldName="student.username"></s:fielderror></td>
                    </tr>
                    <tr>........</tr>
                    <tr><td><s:submit value="%{getText('submit')}"></s:submit></td></tr>
                </table>
            </s:form>
        4.编写验证文件和验证规则
            <validators>
                <field name="student.username">
                    <field-validator type="requiredstring">
                        <param name="trim">true</param>
                        <message key="username.null"></message>    //当无需国际化时候.元素text直接可以写错误消息提示:用户名不能为空
                    </field-validator>
                    <field-validator type="stringlength">
                        <param name="minLength">6</param>
                        <param name="maxLength">15</param>
                        <message key="username.length"></message>//当无需国际化时候:用户名长度在${minLenght}和${maxLength}之间
                    </field-validator>
                </field>
            </validators>        
        5.创建国际化文件
            1.默认的格式文件        message.properties
            2.英文格式文件            message_en.properties
            3.中文香港格式文件        message_zh_HK.properties
                page.title=注册首页
                page.info=新用户注册
                username=用户名
                user.null=用户名不能为空
                user.length=用户名的长度在${minLenght}和${maxLength}之间
                password=密码
                .......
                email.regex=email的格式不正确
                repassword.same=两次输入的密码不一致