HTML中的事件属性要怎么理解？？

Posted

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了HTML中的事件属性要怎么理解？？相关的知识，希望对你有一定的参考价值。

参考技术A 就是当用户操作一个 html 元素(如按钮，文本框，选择框等)时，触发某种事件（如点击事件onclick、值变化事件onchange等），从而启动一段 javascript动作。
常用的事件有几类：
1. 窗口事件，如onload（当页面被载入时执行），onunload;
2. 表单元素事件，如onchange, onsubmit,onreset,onselect,onblur,onfocus;
3. 键盘事件，如onkeydown,onkeypress,onkeyup;
4. 鼠标事件，如onclick, ondbclick,onmousedown, onmouseup,onmouseover,onmouseout,onmousemove;

举个小例子：按钮被点击时触发弹出一个告警框。
<input type="button" name="button1" value="点击试试" onclick="window.alert('让你点你就点啊？')"/>
这里的onclick="javascript函数()"就是HTML的事件属性。
有问题再问吧。

理解Struts2的Action中的setter方法是怎么工作的

接触过webwork和Struts2的同行都应该知道，

提交表单的时候，只要Action中的属性有setter 方法，这些表单数据就可以正确赋值到Action中属性里；
另外对于Spring配置文件中声明的bean，也可以在Action中声明setter 方法将其注入到Action实例中。
那么现在要研究：这些是怎么工作的呢？

 

(1)提交表单时的参数 
在struts2-core-2.3.1.2.jar压缩包内的struts-default.xml配置文件中有这个配置：
<interceptor name="params" class="com.opensymphony.xwork2.interceptor.ParametersInterceptor"/>
这个拦截器是负责解析请求中的URL参数，并赋值给action中对应的属性

来看代码：

Java代码  技术分享
  1. //com.opensymphony.xwork2.interceptor.ParametersInterceptor.java  
  2. //主要代码如下：  
  3. //...  
  4.   
  5.     @Override  
  6.     public String doIntercept(ActionInvocation invocation) throws Exception {  
  7.         Object action = invocation.getAction();  
  8.         if (!(action instanceof NoParameters)) {  
  9.             ActionContext ac = invocation.getInvocationContext();  
  10.             final Map<String, Object> parameters = retrieveParameters(ac);  
  11.   
  12.             if (LOG.isDebugEnabled()) {  
  13.                 LOG.debug("Setting params " + getParameterLogMap(parameters));  
  14.             }  
  15.   
  16.             if (parameters != null) {  
  17.                 Map<String, Object> contextMap = ac.getContextMap();  
  18.                 try {  
  19.                     ReflectionContextState.setCreatingNullObjects(contextMap, true);  
  20.                     ReflectionContextState.setDenyMethodExecution(contextMap, true);  
  21.                     ReflectionContextState.setReportingConversionErrors(contextMap, true);  
  22.   
  23.                     ValueStack stack = ac.getValueStack();  
  24.                     setParameters(action, stack, parameters);  
  25.                 } finally {  
  26.                     ReflectionContextState.setCreatingNullObjects(contextMap, false);  
  27.                     ReflectionContextState.setDenyMethodExecution(contextMap, false);  
  28.                     ReflectionContextState.setReportingConversionErrors(contextMap, false);  
  29.                 }  
  30.             }  
  31.         }  
  32.         return invocation.invoke();  
  33.     }  
  34.   
  35.     protected void setParameters(Object action, ValueStack stack, final Map<String, Object> parameters) {  
  36.         ParameterNameAware parameterNameAware = (action instanceof ParameterNameAware)  
  37.                 ? (ParameterNameAware) action : null;  
  38.   
  39.         Map<String, Object> params;  
  40.         Map<String, Object> acceptableParameters;  
  41.         if (ordered) {  
  42.             params = new TreeMap<String, Object>(getOrderedComparator());  
  43.             acceptableParameters = new TreeMap<String, Object>(getOrderedComparator());  
  44.             params.putAll(parameters);  
  45.         } else {  
  46.             params = new TreeMap<String, Object>(parameters);  
  47.             acceptableParameters = new TreeMap<String, Object>();  
  48.         }  
  49.   
  50.         for (Map.Entry<String, Object> entry : params.entrySet()) {  
  51.             String name = entry.getKey();  
  52.   
  53.             boolean acceptableName = acceptableName(name)  
  54.                     && (parameterNameAware == null  
  55.                     || parameterNameAware.acceptableParameterName(name));  
  56.   
  57.             if (acceptableName) {  
  58.                 acceptableParameters.put(name, entry.getValue());  
  59.             }  
  60.         }  
  61.   
  62.         ValueStack newStack = valueStackFactory.createValueStack(stack);  
  63.         boolean clearableStack = newStack instanceof ClearableValueStack;  
  64.         if (clearableStack) {  
  65.             //if the stack‘s context can be cleared, do that to prevent OGNL  
  66.             //from having access to objects in the stack, see XW-641  
  67.             ((ClearableValueStack)newStack).clearContextValues();  
  68.             Map<String, Object> context = newStack.getContext();  
  69.             ReflectionContextState.setCreatingNullObjects(context, true);  
  70.             ReflectionContextState.setDenyMethodExecution(context, true);  
  71.             ReflectionContextState.setReportingConversionErrors(context, true);  
  72.   
  73.             //keep locale from original context  
  74.             context.put(ActionContext.LOCALE, stack.getContext().get(ActionContext.LOCALE));  
  75.         }  
  76.   
  77.         boolean memberAccessStack = newStack instanceof MemberAccessValueStack;  
  78.         if (memberAccessStack) {  
  79.             //block or allow access to properties  
  80.             //see WW-2761 for more details  
  81.             MemberAccessValueStack accessValueStack = (MemberAccessValueStack) newStack;  
  82.             accessValueStack.setAcceptProperties(acceptParams);  
  83.             accessValueStack.setExcludeProperties(excludeParams);  
  84.         }  
  85.   
  86.         for (Map.Entry<String, Object> entry : acceptableParameters.entrySet()) {  
  87.             String name = entry.getKey();  
  88.             Object value = entry.getValue();  
  89.             try {  
  90.                 newStack.setParameter(name, value);  
  91.             } catch (RuntimeException e) {  
  92.                 if (devMode) {  
  93.                     String developerNotification = LocalizedTextUtil.findText(ParametersInterceptor.class, "devmode.notification", ActionContext.getContext().getLocale(), "Developer Notification:\n{0}", new Object[]{  
  94.                              "Unexpected Exception caught setting ‘" + name + "‘ on ‘" + action.getClass() + ": " + e.getMessage()  
  95.                     });  
  96.                     LOG.error(developerNotification);  
  97.                     if (action instanceof ValidationAware) {  
  98.                         ((ValidationAware) action).addActionMessage(developerNotification);  
  99.                     }  
  100.                 }  
  101.             }  
  102.         }  
  103.   
  104.         if (clearableStack && (stack.getContext() != null) && (newStack.getContext() != null))  
  105.             stack.getContext().put(ActionContext.CONVERSION_ERRORS, newStack.getContext().get(ActionContext.CONVERSION_ERRORS));  
  106.   
  107.         addParametersToContext(ActionContext.getContext(), acceptableParameters);  
  108.     }  
  109. //...  

 

上面的代码ValueStack stack = ac.getValueStack(); 
表明，它是从当前Action上下文获取值栈（其实就类似一个全局Map集合，用来存储参数值或struts上下文全局变量），
然后由判断如果是当前action可以接受的参数（Action中有setter方法）就过滤出来，
调用这句“newStack.setParameter(name, value); ”来保存到值栈中，
保存到了值栈中其实action实例的属性就能拿到值了。
最后一句“addParametersToContext(ActionContext.getContext(), acceptableParameters); ”
表明它还把这些过滤出来的参数保存到了ActionContext上下文中，
这样，如果跳转的类型是forward(服务器内部重定向)，
目标url中就会带上上次请求的url的所有有用的参数。

 

(2) Spring配置bean注入到Action中 
来看一个简单的Action类：

Java代码  技术分享
  1. package com.liany.demo.pubs.org.employee.action;  
  2.   
  3. import java.util.List;  
  4.   
  5. import com.opensymphony.xwork2.ActionSupport;  
  6.   
  7. import com.liany.demo.pubs.org.employee.model.Employee;  
  8. import com.liany.demo.pubs.org.employee.service.EmployeeService;  
  9.   
  10. public class EmployeeAction extends ActionSupport{  
  11.       
  12.     private EmployeeService employeeService;  
  13.     private List list;   
  14.     private Employee employee = new Employee();    
  15.       
  16.       
  17.     public StringReader getStringReader() {  
  18.         StringReader is = null;  
  19.         try {  
  20.             is = new StringReader(xmlBuf.toString());  
  21.         } catch (Exception e) {  
  22.             e.printStackTrace();  
  23.         }  
  24.         return is;  
  25.     }  
  26.       
  27.     public Employee getEmployee() {  
  28.         return employee;  
  29.     }  
  30.   
  31.     public void setEmployee(Employee employee) {  
  32.         this.employee = employee;  
  33.     }   
  34.   
  35.     public List getList() {  
  36.         return list;  
  37.     }  
  38.   
  39.     public void setEmployeeService(EmployeeService employeeService) {  
  40.         this.employeeService = employeeService;  
  41.     }  
  42.       
  43.     public String execute(){  
  44.         //列表  
  45.         list = this.employeeService.getEmployees();  
  46.           
  47.         return "list";  
  48.     }  
  49.       
  50.     public String view(){  
  51.         employee = this.employeeService.getEmployeeById(employee.getId());  
  52.           
  53.         return "view";  
  54.     }  
  55.       
  56.     public String edit(){  
  57.         if(employee.getId()!=null){  
  58.             //修改  
  59.             employee = this.employeeService.getEmployeeById(employee.getId());  
  60.         }else{  
  61.             //新增  
  62.             employee.setId(null);  
  63.         }  
  64.           
  65.         return "input";  
  66.     }  
  67.       
  68.     public String save(){  
  69.         this.employeeService.saveEmployee(employee);  
  70.           
  71.         return "repage";  
  72.     }  
  73.       
  74.     public String delete(){  
  75.         this.employeeService.deleteEmployeeById(employee.getId());  
  76.           
  77.         return "repage";  
  78.     }  
  79. }  

 

上面Action中的employeeService对象其实是在Spring配置文件中声明的bean,
代码中给它定义一个public的setEmployeeService()方法,这样就可以将bean实例注入到
Action中的实例中，这个功能是在Struts过虑器初始化的时候初始化了一个全局变量，
从而使得调用action时，从spring ioc容器中找到这个bean,再set给action对象。
配置文件是在struts.properties 文件中声明：
struts.objectFactory = spring
struts.objectFactory.spring.autoWire = name

以上是关于HTML中的事件属性要怎么理解？？的主要内容，如果未能解决你的问题，请参考以下文章

理解Javascript中的事件绑定与事件委托

深入理解DOM事件类型系列第五篇——文本事件

快速理解C#中的委托与事件

利用维度知识理解CSS中的定位属性

php中__set和__get要怎么理解？

深入理解JavaScript事件冒泡