第一步：webroot/web-inf下简历str.tld文件

  1.  <?xml version="1.0" encoding="UTF-8"?>
  2.      <!DOCTYPE taglib PUBLIC "-//Sun Microsystems, Inc.//DTD JSP Tag Library 1.1//EN" "http://java.sun.com/j2ee/dtds/web-jsptaglibrary_1_1.dtd">
  3.      <taglib>     <!-- 自定义库标签的根 -->
  4.      <tlibversion>1.2</tlibversion>     <!-- 版本号 -->
  5.      <jspversion>1.1</jspversion>       <!-- JSP版本号 -->
  6.      <shortname>stu</shortname>        <!-- prefix="stu"标签名称-->
  7.      <uri>StudentTags</uri>   <!-- uri="StudentTags" 外界导入标签时，认识的名字，很重要。-->  
  8.  
  9.      <tag>
  10.       <name>selectAll</name>                            <!-- 标签名称 -->
  11.       <tagclass>com.bjsxt.sxf.tag.SeclectAllSt</tagclass>          <!-- 对应的java类的全路径 -->
  12.      </tag>  
  13.  
  14.      <!-- 有属性的标签，可以有多个属性  <attribute>并列 -->
  15.        <tag>
  16.             <name>selectBySex</name>  <!-- 标签名称 -->
  17.              <tagclass>com.bjsxt.sxf.tag.SeclectStBySex</tagclass>
  18.              <attribute>   <!-- 对应标签的属性。 -->
  19.                   <name>sex</name>
  20.                   <required>true</required>  <!-- 是必需写的属性，即没有写属性标签不能被正常使用 -->
  21.              </attribute>
  22.         </tag>
  23.        <!-- 按班级学生id查询出班级集合，存放到属性var指定的变量中，然后利用s标签的迭代标签，将var指定的变量存放的学生集合遍历出来 -->
  24.         <tag>
  25.                 <name>selectByClassId</name> <!-- 标签名称 -->
  26.                 <tagclass>com.bjsxt.sxf.tag.MyTag</tagclass> <!-- 对应的java类的全路径 -->
  27.                 <body-content>JSP</body-content><!-- 如果不需要标签体则设置empty，反之设定jsp，内部可以运行jsp所有的语法 -->
  28.                 <attribute>
  29.                     <name>classId</name><!--指定属性名 和标签java类一致-->
  30.                     <required>true</required><!--该属性是否是必须，如果非必须没设置则为空。 -->
  31.                     <rtexprvalue>true</rtexprvalue><!-- 该属性能不能动态使用表达式为该属性赋值 true可以  false不可以  使用脚本和EL表达式来获取动态的值 -->
  32.                 </attribute>
  33.                 <attribute>
  34.                     <name>var</name>
  35.                     <required>true</required>
  36.                     <rtexprvalue>false</rtexprvalue>
  37.                 </attribute>
  38.                 <attribute>
  39.                     <name>num</name>
  40.                     <required>false</required>
  41.                     <rtexprvalue>false</rtexprvalue>
  42.                 </attribute>
  43.         </tag>
  44.         <!-- 自定义的myif标签 -->
  45.         <tag>
  46.                 <name>myif</name>
  47.                 <tagclass>com.bjsxt.sxf.tag.MyIfTag</tagclass>
  48.                 <bodycontent>JSP</bodycontent>
  49.                 <attribute>
  50.                     <name>flag</name>
  51.                     <required>true</required>
  52.                     <rtexprvalue>true</rtexprvalue>
  53.                 </attribute>
  54.                 <attribute>
  55.                     <name>condition</name>
  56.                     <required>true</required>
  57.                     <rtexprvalue>true</rtexprvalue>
  58.                 </attribute>
  59.         </tag>
  60.         <!-- 自定义的myelseif标签 -->
  61.          <tag>
  62.                 <name>myelseif</name>
  63.                 <tagclass>com.bjsxt.sxf.tag.MyElseIfTag</tagclass>
  64.                 <bodycontent>JSP</bodycontent>
  65.                 <attribute>
  66.                     <name>flag</name>
  67.                     <required>true</required>
  68.                     <rtexprvalue>true</rtexprvalue>
  69.                 </attribute>
  70.                 <attribute>
  71.                     <name>condition</name>
  72.                     <required>true</required>
  73.                     <rtexprvalue>true</rtexprvalue>
  74.                 </attribute>
  75.         </tag>
  76.         <!-- 自定义的myelse标签 -->
  77.         <tag>
  78.                 <name>myelse</name>
  79.                 <tagclass>com.bjsxt.sxf.tag.MyElseTag</tagclass>
  80.                 <bodycontent>JSP</bodycontent>
  81.         </tag>
  82.  
  83.      </taglib>

第二步：建立标签类

  1.  package com.bjsxt.sxf.tag;
  2.  
  3.  import javax.servlet.http.HttpServletRequest;
  4.  import javax.servlet.http.HttpServletResponse;
  5.  
  6.  import org.apache.struts2.components.Component;
  7.  import org.apache.struts2.views.jsp.ComponentTagSupport;
  8.  
  9.  import com.bjsxt.sxf.tag.compant.MyIfComponent;
  10.  import com.opensymphony.xwork2.util.ValueStack;
  11.  /**
  12.   * myif的标签类
  13.  * @ClassName: MyIfTag
  14.  * @Description: TODO(这里用一句话描述这个类的作用)
  15.  * @author 尚晓飞
  16.  * @date 2014-10-22 下午3:46:45
  17.  *
  18.   */
  19.  public class MyIfTag extends ComponentTagSupport {
  20.      private String flag;//if判断的标示
  21.      private String condition;//可以传递的多个参数代表
  22.  
  23.      //生成标签逻辑类的对象。多态。父类引用，指向子类对象
  24.      @Override
  25.      public Component getBean(ValueStack arg0, HttpServletRequest arg1,
  26.              HttpServletResponse arg2) {
  27.          return new MyIfComponent(arg0, arg1,arg2);
  28.      }
  29.  
  30.      //给逻辑类的属性赋值
  31.      @Override
  32.      protected void populateParams() {
  33.          super.populateParams();
  34.          MyIfComponent myIfComponent=(MyIfComponent) getComponent();
  35.          myIfComponent.setFlag(flag);
  36.          myIfComponent.setCondition(condition);
  37.      }
  38.  
  39.      public String getFlag() {
  40.          return flag;
  41.      }
  42.  
  43.      public void setFlag(String flag) {
  44.          this.flag = flag;
  45.      }
  46.  
  47.      public String getCondition() {
  48.          return condition;
  49.      }
  50.  
  51.      public void setCondition(String condition) {
  52.          this.condition = condition;
  53.      }
  54.  
  55.  }
  56.  
  57.  package com.bjsxt.sxf.tag;
  58.  
  59.  import javax.servlet.http.HttpServletRequest;
  60.  import javax.servlet.http.HttpServletResponse;
  61.  
  62.  import org.apache.struts2.components.Component;
  63.  import org.apache.struts2.views.jsp.ComponentTagSupport;
  64.  
  65.  import com.bjsxt.sxf.tag.compant.MyElseIfComponent;
  66.  import com.opensymphony.xwork2.util.ValueStack;
  67.  /**
  68.   * myelseif的标签类
  69.  * @ClassName: MyElseIfTag
  70.  * @Description: TODO(这里用一句话描述这个类的作用)
  71.  * @author 尚晓飞
  72.  * @date 2014-10-22 下午3:47:59
  73.  *
  74.   */
  75.  public class MyElseIfTag extends ComponentTagSupport{
  76.      private String flag;//elsif判断的标示
  77.      private String condition;//可以传递的多个参数代表
  78.  
  79.      //返回该标签逻辑类的对象
  80.      @Override
  81.      public Component getBean(ValueStack arg0, HttpServletRequest arg1,
  82.              HttpServletResponse arg2) {
  83.  
  84.          return new MyElseIfComponent(arg0, arg1, arg2);
  85.      }
  86.  
  87.      //给该标签逻辑类对象赋值
  88.      @Override
  89.      protected void populateParams() {
  90.          super.populateParams();
  91.          MyElseIfComponent myElseIfComponent=(MyElseIfComponent) getComponent();
  92.          myElseIfComponent.setFlag(flag);
  93.          myElseIfComponent.setCondition(condition);
  94.      }
  95.      public String getFlag() {
  96.          return flag;
  97.      }
  98.      public void setFlag(String flag) {
  99.          this.flag = flag;
  100.      }
  101.      public String getCondition() {
  102.          return condition;
  103.      }
  104.      public void setCondition(String condition) {
  105.          this.condition = condition;
  106.      }
  107.  
  108.  }
  109.  
  110.  package com.bjsxt.sxf.tag;
  111.  
  112.  import javax.servlet.http.HttpServletRequest;
  113.  import javax.servlet.http.HttpServletResponse;
  114.  
  115.  import org.apache.struts2.components.Component;
  116.  import org.apache.struts2.views.jsp.ComponentTagSupport;
  117.  
  118.  import com.bjsxt.sxf.tag.compant.MyElseComponent;
  119.  import com.opensymphony.xwork2.util.ValueStack;
  120.  /**
  121.   * 自定义的else标签
  122.  * @ClassName: MyElse
  123.  * @Description: TODO(这里用一句话描述这个类的作用)
  124.  * @author 尚晓飞
  125.  * @date 2014-10-22 下午2:24:30
  126.  *
  127.   */
  128.  public class MyElseTag extends ComponentTagSupport{
  129.  
  130.      @Override
  131.      public Component getBean(ValueStack arg0, HttpServletRequest arg1,
  132.              HttpServletResponse arg2) {
  133.          // TODO Auto-generated method stub
  134.          return new MyElseComponent(arg0, arg1, arg2);
  135.      }
  136.  
  137.      @Override
  138.      protected void populateParams() {
  139.          // TODO Auto-generated method stub
  140.          super.populateParams();
  141.      }
  142.  
  143.  }

第三步：建立标签逻辑类

  1.  package com.bjsxt.sxf.tag.compant;
  2.  
  3.  import java.io.Writer;
  4.  
  5.  import javax.servlet.http.HttpServletRequest;
  6.  import javax.servlet.http.HttpServletResponse;
  7.  
  8.  import org.apache.struts2.components.Component;
  9.  
  10.  import com.opensymphony.xwork2.util.ValueStack;
  11.  
  12.  /**
  13.   * myif标签逻辑类 没有@的标签注解，好像不影响，
  14.  * @ClassName: MyIfComponent
  15.  * @Description: TODO(这里用一句话描述这个类的作用)
  16.  * @author 尚晓飞
  17.  * @date 2014-10-22 下午3:49:40
  18.  *
  19.   */
  20.  public class MyIfComponent extends Component {
  21.      protected String flag;
  22.      protected String condition;
  23.      public static final String MyANSWER = "struts.if.answer";
  24.      protected Boolean answer;
  25.  
  26.      public MyIfComponent(ValueStack stack,HttpServletRequest req,HttpServletResponse resp) {
  27.          super(stack);
  28.      }
  29.  
  30.      //标签运行开始执行
  31.      @Override
  32.      public boolean start(Writer writer) {
  33.          answer = (Boolean) findValue(flag, Boolean.class);
  34.          if (answer == null) {
  35.                  answer = Boolean.FALSE;
  36.              }
  37.  
  38.          stack.getContext().put(MyANSWER, answer);
  39.          boolean flg=answer.booleanValue();
  40.          return flg;
  41.      }
  42.  
  43.      //标签运行结束执行
  44.      @Override
  45.      public boolean end(Writer writer, String body) {
  46.          stack.getContext().put(MyANSWER, answer);
  47.          boolean fd=super.end(writer, body);
  48.          return fd;
  49.      }
  50.      public String getFlag() {
  51.          return flag;
  52.      }
  53.  
  54.      public void setFlag(String flag) {
  55.          this.flag = flag;
  56.      }
  57.  
  58.      public String getCondition() {
  59.          return condition;
  60.      }
  61.  
  62.      public void setCondition(String condition) {
  63.          this.condition = condition;
  64.      }
  65.  
  66.  }
  67.  
  68.  package com.bjsxt.sxf.tag.compant;
  69.  
  70.  import java.io.Writer;
  71.  import java.util.Map;
  72.  
  73.  import javax.servlet.http.HttpServletRequest;
  74.  import javax.servlet.http.HttpServletResponse;
  75.  
  76.  import org.apache.struts2.components.Component;
  77.  
  78.  import com.opensymphony.xwork2.util.ValueStack;
  79.  
  80.  /**
  81.   * myelseif的逻辑类
  82.  * @ClassName: MyElseIfComponent
  83.  * @Description: TODO(这里用一句话描述这个类的作用)
  84.  * @author 尚晓飞
  85.  * @date 2014-10-22 下午3:50:49
  86.  *
  87.   */
  88.  public class MyElseIfComponent extends Component {
  89.      protected String flag;
  90.      protected String condition;
  91.      public static final String MyANSWER = "struts.myelseif.answer";
  92.      protected Boolean answer;
  93.  
  94.      public MyElseIfComponent(ValueStack stack,HttpServletRequest req,HttpServletResponse resp) {
  95.          super(stack);
  96.          // TODO Auto-generated constructor stub
  97.      }
  98.  
  99.      @Override
  100.      public boolean start(Writer writer) {
  101.          boolean myflag=false;
  102.          //获取值栈
  103.           Map context = stack.getContext();
  104.          //先从值栈中获取if标签的flag的值
  105.           Boolean ifResult = (Boolean) context.get(MyIfComponent.MyANSWER);
  106.          //如果存在elseif 则需要获取该值
  107.           Boolean elseIfResult=(Boolean) context.get(MyElseIfComponent.MyANSWER);
  108.           context.remove(MyIfComponent.MyANSWER);
  109.           context.remove(MyElseIfComponent.MyANSWER);
  110.  
  111.          //判断是否存在if=true的情况
  112.          if(ifResult!=null&&ifResult==true){
  113.              //if=true
  114.               myflag=false;
  115.          }else{
  116.              //if=false
  117.              //是否存在else if
  118.              if(elseIfResult!=null&&elseIfResult==true){
  119.                  //else if=true;
  120.                  myflag=false;
  121.              }else{
  122.                  //else if=false或者不存在上个else if
  123.                  answer = (Boolean) findValue(flag, Boolean.class);
  124.                  if (answer == null) {
  125.                      answer = Boolean.FALSE;
  126.                  }
  127.                  stack.getContext().put(MyANSWER, answer);
  128.                  myflag=answer.booleanValue();
  129.              }
  130.          }
  131.          return myflag;
  132.      }
  133.      @Override
  134.      public boolean end(Writer writer, String body) {
  135.          stack.getContext().put(MyANSWER, answer);
  136.          return super.end(writer, body);
  137.      }
  138.      public String getFlag() {
  139.          return flag;
  140.      }
  141.      public void setFlag(String flag) {
  142.          this.flag = flag;
  143.      }
  144.      public String getCondition() {
  145.          return condition;
  146.      }
  147.      public void setCondition(String condition) {
  148.          this.condition = condition;
  149.      }
  150.      public Boolean getAnswer() {
  151.          return answer;
  152.      }
  153.      public void setAnswer(Boolean answer) {
  154.          this.answer = answer;
  155.      }
  156.  
  157.  }
  158.  
  159.  package com.bjsxt.sxf.tag.compant;
  160.  
  161.  import java.io.Writer;
  162.  import java.util.Map;
  163.  
  164.  import javax.servlet.http.HttpServletRequest;
  165.  import javax.servlet.http.HttpServletResponse;
  166.  
  167.  import org.apache.struts2.components.Component;
  168.  
  169.  import com.opensymphony.xwork2.util.ValueStack;
  170.  
  171.  public class MyElseComponent extends Component{
  172.  
  173.      /**
  174.       * myelse的逻辑类
  175.       *
  176.       * @Title: EncodingRequestWrapper
  177.       * @Description: 构造函数
  178.       * @param stack
  179.       * @param req
  180.       * @param response
  181.       * @author 尚晓飞
  182.       * @date 2014-10-22 下午3:51:24
  183.       */
  184.      public MyElseComponent(ValueStack stack,HttpServletRequest req,HttpServletResponse response) {
  185.          super(stack);
  186.      }
  187.      //Myelse标签运行开始
  188.      @Override
  189.      public boolean start(Writer writer) {
  190.          boolean myflg=false;
  191.          //获取值栈
  192.           Map context = stack.getContext();
  193.           //获取if的值
  194.           Boolean ifResult = (Boolean) context.get(MyIfComponent.MyANSWER);
  195.           //获取else的值
  196.           Boolean elseifResult=(Boolean) context.get(MyElseIfComponent.MyANSWER);
  197.           //移除值栈中的值
  198.           context.remove(MyIfComponent.MyANSWER);
  199.           context.remove(MyElseIfComponent.MyANSWER);
  200.  
  201.           //判断是否存在if
  202.           if(ifResult!=null&&ifResult==true){
  203.               //存在if，并且为true;
  204.               myflg=false;
  205.           }else{
  206.               //if为false
  207.               //判断elseif是否存在
  208.               if(elseifResult!=null&&elseifResult==true){
  209.                   //存在elseif标签,且==true
  210.                   myflg=false;
  211.               }else{
  212.                   //不存在elseif标签或者为elseif标签==false或者if标签为false
  213.                   myflg=true;
  214.               }
  215.           }
  216.  
  217.           return myflg;
  218.      }
  219.  
  220.      @Override
  221.      public boolean end(Writer writer, String body) {
  222.          // TODO Auto-generated method stub
  223.          boolean d=super.end(writer, body);
  224.          return d;
  225.      }
  226.  
  227.  }

第四步：测试页面

  1.  <%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
  2.  <%@ taglib uri="StudentTags" prefix="stu" %>
  3.  <%@ taglib uri="/struts-tags" prefix="s"%>
  4.  <%
  5.  String path = request.getContextPath();
  6.  String basePath = request.getScheme()+"://"+request.getServerName()+":"+request.getServerPort()+path+"/";
  7.  %>
  8.  
  9.  <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
  10.  <html>
  11.    <head>
  12.    </head>
  13.  
  14.    <body>
  15.      This is my JSP page. <br>
  16.      <a href="<%=request.getContextPath()%>/StudentAction!reportStudent.action">班级表单下载</a>
  17.      <h1>查询出所有学生的标签效果</h1>
  18.         <stu:selectAll></stu:selectAll>
  19.         <h1>查询出指定性别的学生的标签效果</h1>
  20.         <stu:selectBySex sex="男"></stu:selectBySex>
  21.         <h1>查询出指定班级id的学生集合的标签效果</h1>
  22.         <stu:selectByClassId var="students" classId="1" >
  23.             <table border="2">
  24.                 <tr>
  25.                     <td>id</td>
  26.                     <td>姓名</td>
  27.                     <td>性别</td>
  28.                     <td>班级</td>
  29.                 </tr>
  30.                 <s:iterator value="#students" var="stu">
  31.                     <tr>
  32.                         <td><s:property value="#stu.id"/></td>
  33.                         <td><s:property value="#stu.name"/></td>
  34.                         <td><s:property value="#stu.sex"/></td>
  35.                         <td><s:property value="#stu.classRoom.name"/></td>
  36.                     </tr>
  37.                 </s:iterator>
  38.             </table>
  39.         </stu:selectByClassId>
  40.  
  41.         <h1>我是中国人</h1>
  42.         <stu:myif flag="1==3" condition="shangxiaofei">
  43.             <h1>myif是true</h1>
  44.         </stu:myif>
  45.         <stu:myelseif flag="1==2" condition="first">
  46.             <h1>第一个myelseif是false</h1>
  47.         </stu:myelseif>
  48.         <stu:myelseif flag="1==1" condition="sencod">
  49.             <h1>第二个myelseif是true</h1>
  50.         </stu:myelseif>
  51.         <stu:myelse>
  52.             <h1>false</h1>
  53.         </stu:myelse>
  54.    </body>
  55.  
  56.  </html>

第五步:效果图

Struts2自定义标签3模仿原有的s:if s:elseif s:else自定义自己的if elsif else的更多相关文章

  1. JAVA POI替换EXCEL模板中自定义标签（XLSX版本）满足替换多个SHEET中自定义标签

    个人说明:为了简单实现导出数据较少的EXCEL(根据自定义书签模板) 一.替换Excel表格标签方法```/** * 替换Excel模板文件内容 * @param map * 需要替换的标签建筑队形式 ...

  2. Java Web 自定义标签

    1.   自定义标签 由于在JSP页面中直接嵌入Java代码会导致页面开起来非常混乱,不方便和美工等配合工作,为此,JSP提供了自定义标签技术,可以代替直接嵌入Java代码的方式提供动态逻辑,但自定义 ...

  3. 使用自定义标签模拟jstl的<c:for each>标签

    一.自定义标签的基本编写 下面编写一个自定义标签,它可以输出当前的时间. 1.编写标签类 类可以通过继承SimpleTagSupport类实现一个标签类编写.父类为我们提供了一些编写自定义标签的快捷的 ...

  4. JSP自定义标签/自定义标签打包

    有这样一个业务需求: 当我们在编辑某个用户时,需要设置该用户的角色,在转到编辑页面时,就需要自动勾选上该用户已经选择的角色,如下图: 当我们点击编辑时,会查询用户详细信息,以及角色集合传到编辑页面. ...

  5. 【JSP】自定义标签开发入门

    JSP 自定义标签 自定义标签是用户定义的JSP语言元素.当JSP页面包含一个自定义标签时将被转化为servlet,标签转化为对被 称为tag handler的对象的操作,即当servlet执行时We ...

  6. ssm+jsp+自定义标签实现分页，可以通用（前端实现）

    近期做了一些分页方面的开发,大致梳理一下 1 jsp页面上关于分页的代码 <tr> <td colspan="9"> <ule1:pagination ...

  7. JSP自定义标签——简单标签(1)

    前面一篇博客介绍了自定义标签的传统标签使用方式,但是我们会发现,使用传统标签非常的麻烦,而且接口还多,现在传统标签基本都没用了,除了一些比较久的框架.Sun公司之后推出了一个新的标签使用方式,称之为简 ...

  8. 剖析html对标准标签和自定义标签闭合与不闭合渲染问题

    昨天在修改去年写的系统的时候无意中看到了当时写的一个利用标准标签未闭合在单元格内把整个单元格颜色渲染成红色的效果,如下: 当时的问题是从后台返回来的是个int整数而%是写在页面上的如图 这 时候就出现 ...

  9. Spring源码学习-容器BeanFactory(四) BeanDefinition的创建-自定义标签的解析.md

    写在前面 上文Spring源码学习-容器BeanFactory(三) BeanDefinition的创建-解析Spring的默认标签对Spring默认标签的解析做了详解,在xml元素的解析中,Spri ...

随机推荐

  1. SQL group by的使用

    ①定义 "group by" 从字面上理解是根据“by"指定的规则对数据进行分组 ②简单示例 ③group by 中的select字段是受限制的 select指定的字段要 ...

  2. Hmtl5 <input>中placeholder属性（新属性）

    Hmtl5 <input>中placeholder属性(新属性) 一.定义和用法 placeholder 属性提供可描述输入字段预期值的提示信息(hint). 该提示会在输入字段为空时显示 ...

  3. Python3.x：os.listdir和os.walk（获取路径方法）的区别

    Python3.x:os.listdir和os.walk(获取路径方法)的区别 1,os.listdir 使用情况:在一个目录下面只有文件,没有文件夹,这个时候可以使用os.listdir: 例如:d ...

  4. Tomcat 启动图解

    Tomcat server.xml结构 startup.bat执行流程 catalina.bat执行流程 Tomcat Server处理一个http请求的过程

  5. HDU 6156 Palindrome Function（数位DP）题解

    思路: 数位dp的操作是dfs+记忆化,我们dp开四维:位置,长度,进制,是否回文.然后每次暴搜记录下每个位置的数字是什么,搜到对称轴另一边需要检查是否符合回文. 终于把友谊赛的题目都补完了...没做 ...

  6. luogu p3366 最小生成树模板

    倒腾了一个小时  自己也没去看网上的 总算自己能写出来模板了 kruskal //最小生成树 每次找最短的边 #include<bits/stdc++.h> using namespace ...

  7. mysql的隔离性和锁

    INNODB的隔离性质 INNODB的事务支持4种隔离机制,分别是 READ UNCOMMITTED, READ COMMITTED, REPEATABLE READ, and SERIALIZABL ...

  8. 详解Python中re.sub--转载

    [背景] Python中的正则表达式方面的功能,很强大. 其中就包括re.sub,实现正则的替换. 功能很强大,所以导致用法稍微有点复杂. 所以当遇到稍微复杂的用法时候,就容易犯错. 所以此处,总结一 ...

  9. python 列表元素替换以及删除

    >>> letters = ['a', 'b', 'c', 'd', 'e', 'f', 'g'] >>> letters ['a', 'b', 'c', 'd', ...

  10. Sql Server 开放4399端口命令行

    netsh advfirewall firewall add rule name="Open Port 80" dir=in action=allow protocol=TCP l ...