JSP学习笔记（五）：自定义标签-JSP1.x

1、任何一个标签都对应一个Java类，该类必须实现Tag接口。

2、一个标签可以通过 tld 文件查找该标签的是实现类，并运行该类的相关方法。

一、简单标签实现

（一）实现Tag接口

1、实现代码：

<span style="font-family:Arial;">package taglib.jsp_one;
import java.io.IOException;
import java.util.ResourceBundle;
import javax.servlet.jsp.JspException;
import javax.servlet.jsp.JspWriter;
import javax.servlet.jsp.PageContext;
import javax.servlet.jsp.tagext.Tag;
/**
 *
 * @Title: 实现方式一：实现Tag接口
 * @Description:
 * @Copyright: Copyright (c) 2015
 * @Company:
 *
 * @author: SAM-SHO
 * @version: 1.0
 * @CreateDate：Feb 16, 2015
 */
public class Copyright implements Tag {

 private Tag parent;//父标签，本例不使用
 private PageContext pageContext;//JSP内容
 @Override
 public int doStartTag() throws JspException {//标签开始执行
  return SKIP_BODY;//跳过标签体
 }

 @Override
 public int doEndTag() throws JspException {//标签结束时执行
  JspWriter out = pageContext.getOut(); //获取 out 对象
  //输出版权信息
  try {
   out.println("<div align=center style='line-height: 22px; font-size: 12px; '>");
   out.println(ResourceBundle.getBundle("copyright").getString("copyright"));
   out.println("</div>");
  } catch (IOException e) {
   throw new JspException(e);
  }
  return EVAL_PAGE;//执行标签后的内容
 }
 @Override
 public Tag getParent() {
  return this.parent;
 }
 @Override
 public void release() {
 }
 @Override
 public void setPageContext(PageContext pageContext) {
  this.pageContext = pageContext;
 }
 @Override
 public void setParent(Tag parent) {
  this.parent = parent;
 }
}
// end</span>

1）两个属性：parent 和 pageContext。parent为该标签的父标签，pageContext 为运行该标签的 JSP 页面。

2、tid 标签库描述文件。默认在/WEB-INF/下

<span style="font-family:Arial;"> <tlibversion>1.0</tlibversion>
 <jspversion>1.1</jspversion>
 <shortname>myTaglib</shortname> <!--推荐使用的prefix -->
 <uri>http://www.may_Taglib.com/tags</uri> <!--引用标签的uri -->
 <info>A simple tab library for the examples</info>
 <!-- 单个标签配置 -->
 <tag>
  <name>copyright</name><!--标签名-->
  <tagclass>taglib.jsp_one.Copyright</tagclass><!--是实现类-->
  <bodycontent>JSP</bodycontent><!--标签体的限制,支持标签体-->
  <info>Copyright tag.</info>
 </tag></span>

1）<shortname> ：推荐使用的prefix

2）<uri> ：引用标签的uri

3）<tag>：配置某个标签

4）<name>：标签名

5）<tagclass>：是实现类

6）<bodycontent>：标签体的限制。有3种取值：

①、empty：不允许有便签体存在。如果有，执行会抛出异常。

②、JSP：允许有标签体存在。可以是JSP代码。

③、tagdependent：允许有标签体存在，但是标签体内的JSP代码不会被执行。

4、动态指定 tid 文件的路径：在 web.xml 中配置（利用jsp的配置）

<span style="font-family:Arial;">   <taglib>
    <taglib-uri>http://www.mayTaglib.com/tags</taglib-uri>
    <taglib-location>/WEB-INF/taglib.tld</taglib-location><!--定义tld文件位置 -->
   </taglib>
</span>

（二）方法的调用顺序

1、Tag 接口源码分析

<span style="font-family:Arial;">public interface Tag extends JspTag {

    public final static int SKIP_BODY = 0;
    public final static int EVAL_BODY_INCLUDE = 1;
    public final static int SKIP_PAGE = 5;
    public final static int EVAL_PAGE = 6;
    void setPageContext(PageContext pc);
    void setParent(Tag t);
    Tag getParent();

    int doStartTag() throws JspException;
    int doEndTag() throws JspException;
    void release();
}</span>

2、执行顺序：

（二）使用TagSupport类

1、多数情况下不需要实现Tag接口，继承TagSupport 类即可。TagSupport 是Java的一个模板类，是实现了pageContext 与parent 的getter 、setter方法以及其他一些功能。需要做的只是根据需要实现 doStartTag() 与doEndTag()方法。

2、实例代码：（tld配置略）

<span style="font-family:Arial;">package taglib.jsp_one;
import java.io.IOException;
import java.util.ResourceBundle;
import javax.servlet.jsp.JspException;
import javax.servlet.jsp.JspWriter;
import javax.servlet.jsp.tagext.TagSupport;
/**
 *
 * @Title: 方式二：继承TagSupport 类
 * @Description:只要实现 doStartTag 与 doEndTag即可
 * @Copyright: Copyright (c) 2015
 * @Company:
 *
 * @author: SAM-SHO
 * @version: 1.0
 * @CreateDate：Feb 16, 2015
 */
public class Copyright2 extends TagSupport {
 private static final long serialVersionUID = -2936770589554413334L;
 @Override
 public int doEndTag() throws JspException {
  JspWriter out = pageContext.getOut();
  try {
   out.println("<div align=center style='line-height: 22px; font-size: 12px; '>");
   out.println(ResourceBundle.getBundle("copyright").getString("copyright"));
   out.println("</div>");
  } catch (IOException e) {
   throw new JspException(e);
  }
  return EVAL_PAGE;
 }
 @Override
 public int doStartTag() throws JspException {
  return super.doStartTag();
 }
}
// end
</span>

（三）支持属性的标签

1、标签的属性是通过 Tag的实现类的 setter 方法注释进去的。因此只需要给标签类增加一个属性以及相应的 setter 方法就可以了。

<span style="font-family:Arial;">package taglib.jsp_one;
import javax.servlet.jsp.JspException;
import javax.servlet.jsp.tagext.TagSupport;
/**
 *
 * @Title: 支持属性的标签
 * @Description:
 * @Copyright: Copyright (c) 2015
 * @Company:
 *
 * @author: SAM-SHO
 * @version: 1.0
 * @CreateDate：Feb 16, 2015
 */
public class HelloTag extends TagSupport {
 private static final long serialVersionUID = -8828591126748246256L;
 private String name;//name属性
 @Override
 public int doEndTag() throws JspException {
  try {
   this.pageContext.getOut().println("Hello, " + name);
  } catch (Exception e) {
   throw new JspException(e);
  }
  return EVAL_PAGE;
 }
 public String getName() {
  return name;
 }
 public void setName(String name) {
  this.name = name;
 }
}
// end</span>

2、tld文件配置：<attribute> 配置属性

<span style="font-family:Arial;"><tag>
  <name>hello</name>
  <tagclass>taglib.jsp_one.HelloTag</tagclass>
  <bodycontent>empty</bodycontent><!--不支持标签体-->
  <info>Hello tag with parameters.</info>
  <attribute>
   <name>name</name><!--name属性-->
   <required>true</required><!--该属性为必须的-->
   <rtexprvalue>true</rtexprvalue><!--是否允许EL表达式 与 jsp标本-->
  </attribute>
 </tag></span>

二、带标签体的实现

（一）实现BodyTag 接口

1、流程图如下：

1）doStartTag()方法返回值，如果为 EVAL_BODY_INCLUDE，则会直接输出标签体内容；

2）如果为 EVAL_BODY_BUFFERED ，则不会输出，而是将标签体内容通过 setBodyContent()方法注释到标签类里，然后就可以使用 getBodyContent() 方法得到标签体的内容。

（二）继承 BodyTagSupport 类

1、通常都是使用继承 BodyTagSupport 类实现，默认的，BodyTagSupport 类会按照中间的主险一直往下执行。

2、实例：

<span style="font-family:Arial;">package taglib.jsp_one;
import javax.servlet.jsp.JspException;
import javax.servlet.jsp.tagext.BodyTagSupport;
/**
 *
 * @Title: 实现标签体的自定义标签，继承BodyTagSupport
 * @Description:
 * @Copyright: Copyright (c) 2015
 * @Company:
 *
 * @author: SAM-SHO
 * @version: 1.0
 * @CreateDate：Feb 16, 2015
 */
public class ToLowerCaseTag extends BodyTagSupport {
 private static final long serialVersionUID = -2529343271020971948L;
 @Override
 public int doEndTag() throws JspException {
  String content = this.getBodyContent().getString();//得到标签体
  try {
   this.pageContext.getOut().print(content.toLowerCase());//输出
  } catch (Exception e) {
  }
  return EVAL_PAGE;
 }
}
// end
</span>

<span style="font-family:Arial;"><tag>
  <name>toLowerCase</name>
  <tagclass>taglib.jsp_one.ToLowerCaseTag</tagclass>
  <bodycontent>JSP</bodycontent>
  <info>Tag with body.</info>
 </tag></span>

3、只要在 setBodyContent(）方法之后被调用的方法中，都可以使用 getBodyContent()方法获取标签体的内容。一般为 doEndTag() 和 doAfterBody() 。

（三）多次执行循环标签体

1、单次执行是指标签体只会被使用一次，二多次执行是指标签体可以被使用多次。由流程图可知，可以控制 doAfterBody()方法的返回值，达到单次还是多次的效果。

<span style="font-family:Arial;">package taglib.jsp_one;
import javax.servlet.jsp.JspException;
import javax.servlet.jsp.tagext.BodyTagSupport;
/**
 *
 * @Title: 多次循环标签体得标签
 * @Description:
 * @Copyright: Copyright (c) 2015
 * @Company:
 *
 * @author: SAM-SHO
 * @version: 1.0
 * @CreateDate：Feb 16, 2015
 */
public class LoopTag extends BodyTagSupport {
 private static final long serialVersionUID = 5882067091737658241L;
 private int times;
 @Override
 public int doStartTag() throws JspException {
  times = 5;
  return super.doStartTag();
 }

 @Override
 public int doAfterBody() throws JspException {
  if (times-- > 0) {
   /** 只要 times > 0 就继续循环，同时 times 自减 */
   try {
    //在 doAfterBody() 方法内输出是写入到 BodyContent缓存中，
    //因此每次 getBodyContent()取出的值都会递增
    this.getPreviousOut().println(this.getBodyContent().getString()+"<br/>");
   } catch (Exception e) {
   }
   return EVAL_BODY_AGAIN;//返回值EVAL_PAGE ，则执行单次
  } else {//小心死循环
   /** 结束运行，同时复原 times */
   times = 5;
   return SKIP_BODY;//结束
  }
 }
}
// end</span>

<span style="font-family:Arial;"> <tag>
  <name>loop</name>
  <tagclass>taglib.jsp_one.LoopTag</tagclass>
  <bodycontent>JSP</bodycontent>
  <info>Tag with body.</info>
 </tag></span>

三、复杂标签

（一）动态参数的标签：实现 DynamicAttributes 接口

1、标签类代码：

<span style="font-family:Arial;">package taglib.jsp_one;
import java.util.HashMap;
import java.util.Map;
import java.util.Map.Entry;
import javax.servlet.jsp.JspException;
import javax.servlet.jsp.JspWriter;
import javax.servlet.jsp.tagext.DynamicAttributes;
import javax.servlet.jsp.tagext.TagSupport;
/**
 *
 * @Title: 动态属性的标签
 * @Description:
 * @Copyright: Copyright (c) 2015
 * @Company:
 *
 * @author: SAM-SHO
 * @version: 1.0
 * @CreateDate：Feb 17, 2015
 */
public class DynamicAttributeTag extends TagSupport implements DynamicAttributes {
 private static final long serialVersionUID = -1477571708507488373L;
 private Map<String, Double> map = new HashMap<String, Double>();//动态参数的容器
 @Override
 public int doEndTag() throws JspException {
  JspWriter out = pageContext.getOut();
  double min = 0, max = 0;
  for (Double d : map.values()) {
   min = Math.min(d, min);
   max = Math.max(d, max);
  }
  StringBuffer buffer = new StringBuffer();
  buffer.append("<table>");
  for (Entry<String, Double> entry : map.entrySet()) {
   buffer.append("<tr>");
   buffer.append("<td>" + entry.getKey() + "</td>");
   buffer.append("<td><img src='../../images/vote.gif' height='10' width='");
   buffer.append((entry.getValue() - min) / (max - min + 1) * 200 + 50);
   buffer.append("' /> " + entry.getValue() + "</td>");
   buffer.append("</tr>");
  }
  buffer.append("</table>");
  try {
   out.write(buffer.toString());
  } catch (Exception e) {
  }
  return super.doEndTag();
 }
 //自动会注释动态参数
 @Override
 public void setDynamicAttribute(String uri, String key, Object value) throws JspException {
  map.put(key, Double.parseDouble((String) value));
 }
}
// end
</span>

2、tld文件配置：

<span style="font-family:Arial;"><tag>
  <name>dynamicAttribute</name>
  <tagclass>taglib.jsp_one.DynamicAttributeTag</tagclass>
  <bodycontent>empty</bodycontent>
  <dynamic-attributes>true</dynamic-attributes><!-- 配置动态属性 -->
  <info>Tag with dynamic attribute.</info>
 </tag></span>

（二）嵌套自定义标签

1、标签代码：

1）父标签

<span style="font-family:Arial;">package taglib.jsp_one.table;
import java.io.IOException;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.jsp.JspException;
import javax.servlet.jsp.JspWriter;
import javax.servlet.jsp.tagext.BodyContent;
import javax.servlet.jsp.tagext.BodyTagSupport;
/**
 *
 * @Title: 嵌套父标签：Table标签
 * @Description:
 * @Copyright: Copyright (c) 2015
 * @Company:
 *
 * @author: SAM-SHO
 * @version: 1.0
 * @CreateDate：Feb 16, 2015
 */
public class Table extends BodyTagSupport {
 private static final long serialVersionUID = 3358444196409845360L;
 /** 存储列信息 */
 private List<Map<String, String>> columns = new ArrayList<Map<String, String>>();
 /** 存储数据，可能为 集合类型的或者数组类型的 */
 private Object items;
 /** 取排序数据的 URL */
 private String url;
 @Override
 public int doStartTag() throws JspException {
  columns.clear();//每次清空
  return super.doStartTag();
 }
 @Override
 public int doAfterBody() throws JspException {
  try {
   BodyContent bc = getBodyContent();
   JspWriter out = bc.getEnclosingWriter();
   HttpServletRequest request = (HttpServletRequest) pageContext.getRequest();
   /** 按哪一列排序 */
   String orderName = request.getParameter("orderName");
   /** 按升序还是降序排序 */
   String orderType = request.getParameter("orderType");
   orderType = "desc".equals(orderType) ? "desc" : "asc";
   out.println("<table id=theObjTable");
   out.println(" class=list_table STYLE='table-layout:fixed;' >");
   out.println(" <tr class=tr_title>");
   out.println(" <script>var columns = []; </script>");
   for (int i = 0; i < columns.size(); i++) {
    /** 获取列信息 */
    Map<String, String> column = columns.get(i);
    /** 列头 */
    String label = column.get("label");
    /** 该列对应的 Java Bean 的属性 */
    String property = column.get("property");
    label = label == null ? property : label;
    out.println("<td id='__id_td_" + property + "'>");
    out.println("<font class='resizeDivClass'");
    out.println(" onmousedown='MouseDownToResize(this);');");
    out.println(" onmousemove='MouseMoveToResize(this);'");
    out.println(" onmouseup='MouseUpToResize(this);'></font>");
    out.println("<span onclick=\"sort('" + property + "'); \"");
    out.println(" style=\"cursor: pointer; \">");
    out.println(label);
    if (property.equals(orderName)) {
     out.println("<img src='../../images/" + orderType + ".gif' border=0/>");
    }
    out.println("</span>");
    out.println("</td>");
    out.println("<script>columns[columns.length] = '__id_td_" + property + "'; </script>");
   }
   out.println(" </tr>");
   if (items != null) {
    /** 遍历所有的数据 */
    for (Object obj : (Iterable) items) {
     out.println(" <tr class=tr_data>");
     for (int i = 0; i < columns.size(); i++) {
      Map<String, String> column = columns.get(i);
      String property = column.get("property");
      String getterStyle = toGetterStyle(property);
      try {
       String getter = "get" + getterStyle;
       String is = "is" + getterStyle;
       Method method = null;
       try {
        /** 获取 getXxx() 形式的方法 */
        method = obj.getClass().getMethod(getter);
       } catch (Exception e) {
       }
       if (method == null) {
        /** 如果没有，获取 isXxx() 形式的方法 */
        method = obj.getClass().getMethod(is);
       }
       method.setAccessible(true);
       /** 获取属性值 */
       Object value = method.invoke(obj);
       out.println("<td><span title='" + value + "'>" + value + "</span></td>");
      } catch (Exception e) {
       throw new JspException(e);
      }
     }
     out.println(" </tr>");
    }
   }
   out.println("</table>");
   out.println("<script>");
   out.println(" var orderName = '" + orderName + "'; ");
   out.println(" var orderType = '" + orderType + "'; ");
   out.println(" function sort(column){");
   out.println(" if(orderName == column){");
   out.println(" location='" + url + "?orderName=' + column + '&orderType=' + (orderType=='asc' ? 'desc' : 'asc'); ");
   out.println(" }");
   out.println(" else{");
   out.println(" location='" + url + "?orderName=' + column + '&orderType=' + orderType; ");
   out.println(" }");
   out.println(" }");
   out.println("</script>");
  } catch (IOException ioe) {
   throw new JspException("Error: " + ioe.getMessage());
  }
  return SKIP_BODY;
 }
 public Object getItems() {
  return items;
 }
 public void setItems(Object items) {
  this.items = items;
 }
 /**
  * 首字母大写
  *
  * @param column
  * @return
  */
 public String toGetterStyle(String column) {
  if (column.length() == 1)
   return column.toUpperCase();
  char ch = column.charAt(0);
  return Character.toUpperCase(ch) + column.substring(1);
 }
 public List<Map<String, String>> getColumns() {
  return columns;
 }
 public void setColumns(List<Map<String, String>> columns) {
  this.columns = columns;
 }
 public String getUrl() {
  return url;
 }
 public void setUrl(String url) {
  this.url = url;
 }
}</span>

<span style="font-family:Arial;"> <tag>
  <name>table</name>
  <tagclass>taglib.jsp_one.table.Table</tagclass>
  <bodycontent>JSP</bodycontent>
  <info>Table tag.</info>
  <attribute>
   <name>items</name>
   <required>true</required>
   <rtexprvalue>true</rtexprvalue>
  </attribute>
  <attribute>
   <name>url</name>
   <required>false</required>
   <rtexprvalue>true</rtexprvalue>
  </attribute>
 </tag>
</span>

2）子标签：

<span style="font-family:Arial;">package taglib.jsp_one.table;
import java.util.HashMap;
import java.util.Map;
import javax.servlet.jsp.JspException;
import javax.servlet.jsp.tagext.TagSupport;
/**
 *
 * @Title: Column 标签
 * @Description:
 * @Copyright: Copyright (c) 2015
 * @Company:
 *
 * @author: SAM-SHO
 * @version: 1.0
 * @CreateDate：Feb 16, 2015
 */
public class Column extends TagSupport {
 private static final long serialVersionUID = 5119493903438602864L;
 private String property;
 private String label;
 private String type;
 public int doStartTag() throws JspException {
  if (!(this.getParent() instanceof Table)) {
   throw new JspException("Column must be inside Table. ");
  }
  Map<String, String> column = new HashMap<String, String>();
  column.put("label", label);
  column.put("property", property);
  column.put("type", type);
  Table table = (Table) this.getParent();
  table.getColumns().add(column);
  return SKIP_BODY;
 }
 public int doEndTag() throws JspException {
  return EVAL_PAGE;
 }
 public String getProperty() {
  return property;
 }
 public void setProperty(String property) {
  this.property = property;
 }
 public String getLabel() {
  return label;
 }
 public void setLabel(String label) {
  this.label = label;
 }
 public String getType() {
  return type;
 }
 public void setType(String type) {
  this.type = type;
 }
}
</span>

<span style="font-family:Arial;"><tag>
  <name>column</name>
  <tagclass>taglib.jsp_one.table.Column</tagclass>
  <bodycontent>empty</bodycontent>
  <info>Column tag.</info>
  <attribute>
   <name>property</name>
   <required>true</required>
   <rtexprvalue>true</rtexprvalue>
  </attribute>
  <attribute>
   <name>label</name>
   <required>false</required>
   <rtexprvalue>true</rtexprvalue>
  </attribute>
 </tag>
</span>

调用标签jsp代码:

<span style="font-family:Arial;"><%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c"%>
<%@ taglib uri="http://www.mayTaglib.com/tags" prefix="myTaglib"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Base JSP</title>
</head>
<body>
<myTaglib:copyright>Hello, myTaglib</myTaglib:copyright>
<myTaglib:toLowerCase>变成全部小写：HELLO,SAM</myTaglib:toLowerCase>
<br/>
<myTaglib:loop>loop> </myTaglib:loop>
<br/>
<myTaglib:dynamicAttribute a="1" b="2" />
<br/>

</body>
</html></span>

时间： 2024-08-02 08:32:51

JSP学习笔记（五）：自定义标签-JSP1.x的相关文章

学习笔记_Java_day13_JSTL_自定义标签库（9）

自定义标签 1 自定义标签概述 1.1 自定义标签的步骤其实我们在JSP页面中使用标签就等于调用某个对象的某个方法一样,例如:<c:if test=””>,这就是在调用对象的方法一样.自定义标签其实就是自定义类一样! l 定义标签处理类:必须是Tag或SimpleTag的实现类: l 编写标签库描述符文件(TLD): SimpleTag接口是JSP2.0中新给出的接口,用来简化自定义标签,所以现在我们基本上都是使用SimpleTag. Tag是老的,传统的自定义标签时使用的接口,现在不建

Servlet&JSP学习笔记

Servlet&JSP学习笔记 */--> Servlet&JSP学习笔记 Table of Contents 1 Web容器 2 内置对象 2.1 内置对象分类 2.1.1 out 2.1.2 request 2.1.3 application 2.1.4 response 2.1.5 session 2.1.6 其他 3 JavaBean 3.1 JSP动作元素 3.2 javabean的四个作用於范围 4 JSP状态管理 4.1 Cookie 4.2 include 指令与动作

[转载]SharePoint 2013搜索学习笔记之自定义结果源

搜索中心新建好之后在搜索结果页上会默认有所有内容,人员,对话,视频这四个结果分类,每个分类会返回指定范围的搜索结果,这里我再添加了部门日志结果分类,搜索这个分类只会返回部门日志内容类型的搜索结果,要实现这个效果,步骤如下: 第一步,进入管理中心,进入管理应用程序,点击Search Service 应用程序,进入搜索管理页,再点击结果源如图: 第二步,新建结果源,填写名称,协议填写本地sharepoint,凭据信息选择默认, 第三步,点击启动查询生成器,生成查询语句,最后点保存,接着继续点新建内容

NLTK学习笔记(五):分类和标注词汇

[TOC] 词性标注器之后的很多工作都需要标注完的词汇.nltk自带英文标注器pos_tag import nltk text = nltk.word_tokenize("And now for something compleyely difference") print(text) print(nltk.pos_tag(text)) 标注语料库表示已经标注的标识符:nltk.tag.str2tuple('word/类型') text = "The/AT grand/J

java之jvm学习笔记五(实践写自己的类装载器)

java之jvm学习笔记五(实践写自己的类装载器) 课程源码:http://download.csdn.net/detail/yfqnihao/4866501 前面第三和第四节我们一直在强调一句话,类装载器和安全管理器是可以被动态扩展的,或者说,他们是可以由用户自己定制的,今天我们就是动手试试,怎么做这部分的实践,当然,在阅读本篇之前,至少要阅读过笔记三. 下面我们先来动态扩展一个类装载器,当然这只是一个比较小的demo,旨在让大家有个比较形象的概念. 第一步,首先定义自己的类装载器,从Clas

WEB前端学习笔记五

接web前端学习笔记第四篇,此篇为web学习笔记五,在此感谢您的采集和转发,但请注明文章出自网知博学. 2.0.3 html标签的属性格式现在我们知道了两个双标签分别是,标题标签:<h1> - <h6>.和段落标签:<p></p>还知道了一个换行的单标签:<br />,现在我们给<p></p>标签添加一个属性,来改变段落是右对齐,还是左对齐,还是居中. 如上图,<p>标签中的 align(中文就是排列的意

Sharepoint2013搜索学习笔记之自定义结果源(七)

Sharepoint2013搜索学习笔记之自定义结果显示模板(九)

搜索结果通过套用定义好的显示模板来展示结果,显示模板由js和html组成,我们可以通过修改显示模板,然后将修改好的显示模板跟搜索结果绑定起来,来修改搜索结果的显示效果,例子如下图: 修改前修改后第一步,确定显示需要修改的显示模板,打开ie,摁f12,定位到搜索结果列表项找到需要修改的搜索项模板第二步,从搜索中心进入网站设置页面第三步,点击web设计器库的母版页和页面布局第四步,进入母版页样式库的 Display Templates/search目录,该目录就是存放搜索结果显示模板的地方

Swift学习笔记五：循环和条件语句

一.循环语句 1. for循环 1) for -in 循环,对于数据范围,序列,集合等中的每一个元素,都执行一次 for a in 0...5{} //循环迭代,从a=0到a=5,执行{}里的代码注意:a只循环中存在,也就是出了{}a就不存在了或者遍历数组 let a = [1,2,3] for b in a{} //循环迭代,从b=1到b=3 如果你不需要序列中的每一个值,可以使用_来忽略它,仅仅只是使用循环体本身: for _ in 0...5{} //循环执行{}里的代码,

Android学习笔记五之Service

Android学习笔记五之Service 1.什么是Service? 什么是Service?Service是Android系统的四大组件之一,官方文档是这样描述Service的: A Service is an application component that can perform long-running operations in the background and does not provide a user interface. Another application comp