Java for Web学习笔记（三七）：自定义tag（5）自定义tld文件

最新推荐文章于 2023-05-16 16:51:30 发布
最新推荐文章于 2023-05-16 16:51:30 发布
阅读量1.2k 收藏
点赞数
分类专栏： JAVA 读书笔记 愷风（Wei）之Java for Web学习笔记
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/flowingflying/article/details/58028645
版权

我们将学习通过tld文件提供时间日期的本地显示格式的tag。

定义TLD

我们需要对tld进行整体描述，创建/WEB-INF/tld/wei.tld文件，如下： 

<?xml version="1.0" encoding="UTF-8"?>
<taglib xmlns="http://java.sun.com/xml/ns/javaee"
        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
        xsi:schemaLocation="http://java.sun.com/xml/ns/javaee
        http://java.sun.com/xml/ns/javaee/web-jsptaglibrary_2_1.xsd"
        version="2.1">
        
    <tlib-version>1.0</tlib-version>
    <short-name>wei</short-name>
    <uri>http://www.flowingflying.wei.cn/jsp/tld/wei</uri>
    <tag>
    	<description><![CDATA[...something...]]></description>
    	<name>formatDate</name>
    	<tag-class>cn.flowingflying.wei.chapter08.FormatDateTag</tag-class>
    	<body-content>empty</body-content>

        <attribute>
            <description>The object representing a date and/or time that should be formatted.</description>
            <name>value</name>
            <required>true</required>
            <rtexprvalue>true</rtexprvalue>
        </attribute>

        <attribute>
            <description>"date" (default), "time", or "both"</description>
            <name>type</name>
            <required>false</required>
            <rtexprvalue>true</rtexprvalue>
            <type>java.lang.String</type>
        </attribute>
 
        ...... 从略 ......
        <dynamic-attributes>false</dynamic-attributes>
    </tag>

    ... functions ...具体见后...现略...    
</taglib>

实现tag handler类

继承TagSupport

cn.flowingflying.wei.chapter08.FormatDateTag是tag的handler，具体实现tag的代码。代码有些长，但是有必要读一下，由于当中越界使用了protected方法以及将方法名字作为参数，请先阅读Method和Function的使用，但请不要被这些花俏的技巧障目，重点关注tag handler的实现。

//【1】tag handler是TagSupport的继承类
public class FormatDateTag extends TagSupport{	
    private static final long serialVersionUID = 1L;
    private static final Method GET_LOCALE_METHOD;
    private static final Method GET_TIME_ZONE_METHOD;

    /* 我们希望直接利用Apache/GlassFish JSTL中处理本地时间和时区的现成的static protected方法，通过refection方式来使用它们。*/
    static {
        try {
            GET_LOCALE_METHOD = SetLocaleSupport.class.getDeclaredMethod(
                    "getFormattingLocale", PageContext.class, Tag.class,boolean.class,boolean.class);
            GET_LOCALE_METHOD.setAccessible(true);

            GET_TIME_ZONE_METHOD = TimeZoneSupport.class.getDeclaredMethod(
                    "getTimeZone", PageContext.class, Tag.class);
            GET_TIME_ZONE_METHOD.setAccessible(true);
        } catch (NoSuchMethodException e) {
            throw new RuntimeException(e);
        }
    }

    //【2】定义属性，具体对应tld中的attribute，相应的定义相关的setters和getters（见后）
    /** The object representing a date and/or time that should be formatted.*/
    protected Object value; 
    /** "date" (default), "time", or "both" */
    protected Type type;    
    /** "default" (default), "short", "medium", "long", or "full" in accordance with java.text.DateFormat.*/
    protected Style dateStyle; 
    /** "default" (default), "short", "medium", "long", or "full" in accordance with java.text.DateFormat. */
    protected Style timeStyle; 
    /** Defaults to false, specify true to put the time before the date. */
    protected boolean timeFirst; 
    /** Defaults to a single space ( ), used to specify a custom value to separate the date and time with. */
    protected String separateDateTimeWith; 
    protected String pattern;
    protected TimeZone timeZone;
    /** Scope variable to save the formatted date to instead of inlining.
     *  Exported scope variable will be of type java.lang.String.*/
    protected String var; 
    protected int scope;

    public FormatDateTag() {
        super();
        init();
    }

    //【3】init()在构造函数和release()中调用，对参数进行初始化。
    // 这很重要，因为容器会重用tag handler来提高效率（也就是不一定新建实例，即没有新建的初始化），之间会调用release()。我们需确保初始化。
    private void init() {
        this.type = Type.DATE;
        this.dateStyle = this.timeStyle = Style.DEFAULT;
        this.timeFirst = false;
        this.separateDateTimeWith = " ";
        this.pattern = this.var = null;
        this.timeZone = null;
        this.scope = PageContext.PAGE_SCOPE;
    }

    @Override
    public void release() {
        this.init();
    }


    /* 【4】doStartTag(),doAfterBody(),doEndTag()是在不同阶段对tag的处理。
     * FormatDate中没有body，所有不需要doAfterBody()，如果带有body，通常需要重写doStartTag()和doAfterBody()。
     * doEndTag()是在关闭tag时调用的，本例就是进行时间日期的翻译，直接打印到页面或者存放在var中。
     */

    @Override
    public int doEndTag() throws JspException{
    	// 4.1】如果value为null，在scope中删除这个var属性，返回Tag.EVAL_PAGE，继续往下走。
        if(this.value == null){
            if(this.var != null)
                pageContext.removeAttribute(this.var, this.scope);
            return Tag.EVAL_PAGE;
        }        

        //4.2】获得formatted。如果有给出locale，需要根据locale进行转换
        String formatted;
        Locale locale = this.getLocale();
        if(locale != null){
            if(this.timeZone == null)
                this.timeZone = this.getTimeZone();
            if(this.timeZone == null)
                this.timeZone = TimeZone.getDefault();

            if(this.value instanceof Date)
                formatted = this.formatDate((Date)this.value, locale);
            else if(this.value instanceof Calendar)
                formatted = this.formatDate(((Calendar)this.value).getTime(), locale);
            else if(this.value instanceof TemporalAccessor)
                formatted = this.formatDate((TemporalAccessor)this.value, locale);
            else
                throw new JspTagException("Unsupported date type " + this.value.getClass().getCanonicalName() + ".");
        }else{
            formatted = this.value.toString();
        }

        //4.3】如果有var就将结果存进去，如无，就输出。
        if(this.var != null){
            this.pageContext.setAttribute(this.var, formatted, this.scope);
        }else{
            try {
                this.pageContext.getOut().print(formatted);
            } catch (IOException e) {
                throw new JspTagException(e.toString(), e);
            }
        }

        return Tag.EVAL_PAGE;
    }

    //进行Date类型的翻译
    private String formatDate(Date value, Locale locale){
        if(this.pattern != null) {
            SimpleDateFormat format = new SimpleDateFormat(this.pattern, locale);
            format.setTimeZone(this.timeZone);
            return format.format(value);
        }

        Function<Date, String> dateFormat = null;
        Function<Date, String> timeFormat = null;

        if(this.type == Type.DATE || this.type == Type.BOTH){
            DateFormat format = DateFormat.getDateInstance(this.dateStyle.getDateFormat(), locale);
            format.setTimeZone(this.timeZone);
            dateFormat = format::format;
        }

        if(this.type == Type.TIME || this.type == Type.BOTH){
            DateFormat format = DateFormat.getTimeInstance(this.timeStyle.getDateFormat(), locale);
            format.setTimeZone(this.timeZone);
            timeFormat = format::format;
        }

        return this.formatDate(dateFormat, timeFormat, value);
    }

    private String formatDate(TemporalAccessor value, Locale locale){
        ZoneId zoneId = this.timeZone.toZoneId();

        if(this.pattern != null)
            return DateTimeFormatter.ofPattern(this.pattern, locale).withZone(zoneId).format(value);

        Function<TemporalAccessor, String> dateFormat = null;
        Function<TemporalAccessor, String> timeFormat = null;

        if(this.type == Type.DATE || this.type == Type.BOTH)
            dateFormat = DateTimeFormatter.ofLocalizedDate(this.dateStyle.getFormatStyle())
                                          .withLocale(locale).withZone(zoneId)::format;
        if(this.type == Type.TIME || this.type == Type.BOTH)
            timeFormat = DateTimeFormatter.ofLocalizedTime(this.timeStyle.getFormatStyle())
                                          .withLocale(locale).withZone(zoneId)::format;

        return this.formatDate(dateFormat, timeFormat, value);
    }

    private <T> String formatDate(Function<T, String> dateFormat,
                                  Function<T, String> timeFormat, T value){
        String formatted = "";
        if(timeFormat != null && this.timeFirst){
            formatted += timeFormat.apply(value);
            if(dateFormat != null)
                formatted += this.separateDateTimeWith;
        }

        if(dateFormat != null)
            formatted += dateFormat.apply(value);

        if(timeFormat != null && !this.timeFirst){
            if(dateFormat != null)
                formatted += this.separateDateTimeWith;
            formatted += timeFormat.apply(value);
        }

        return formatted;
    }

    private Locale getLocale() throws JspTagException{
        try {         
            return (Locale)GET_LOCALE_METHOD.invoke(null, this.pageContext, this, true, true);
        } catch (IllegalAccessException | InvocationTargetException e) {
            throw new JspTagException(e.toString(), e);
        }
    }

    private TimeZone getTimeZone() throws JspTagException{
        try {
            return (TimeZone)GET_TIME_ZONE_METHOD.invoke(null, this.pageContext, this);
        } catch (IllegalAccessException | InvocationTargetException e) {
            throw new JspTagException(e.toString(), e);
        }
    }

    public void setValue(Object value){
        this.value = value;
    }

    public void setType(String type){
        this.type = StringUtils.isBlank(type) ? null : Type.valueOf(type.toUpperCase());
    }

    public void setDateStyle(String style){
        this.dateStyle = StringUtils.isBlank(style) ? null : Style.valueOf(style.toUpperCase());
    }

    public void setTimeStyle(String style){
        this.timeStyle = StringUtils.isBlank(style) ? null : Style.valueOf(style.toUpperCase());
    }

    public void setTimeFirst(boolean timeFirst){
        this.timeFirst = timeFirst;
    }

    public void setSeparateDateTimeWith(String separate){
        this.separateDateTimeWith = StringUtils.isBlank(separate) ? " " : separate;
    }

    public void setPattern(String pattern){
        this.pattern = StringUtils.isBlank(pattern) ? null : pattern;
    }

    public void setTimeZone(Object timeZone){
        if(timeZone instanceof String)
            this.timeZone = StringUtils.isBlank((String)timeZone) ? null : TimeZone.getTimeZone((String)timeZone);
        else if(timeZone instanceof TimeZone)
            this.timeZone = (TimeZone)timeZone;
        else if(timeZone instanceof ZoneId)
            this.timeZone = TimeZone.getTimeZone((ZoneId)timeZone);
        else if(timeZone == null)
            this.timeZone = null;
        else
            throw new IllegalArgumentException("Time zone type " 
                  + timeZone.getClass().getCanonicalName() + " not recognized");
    }

    public void setVar(String var){
        this.var = StringUtils.isBlank(var) ? null : var;
    }

    public void setScope(String scope){
        this.scope = Util.getScope(scope);
    }

    private static enum Type{
        DATE, TIME, BOTH
    }

    private static enum Style{
        DEFAULT(DateFormat.MEDIUM, FormatStyle.MEDIUM),
        SHORT(DateFormat.SHORT, FormatStyle.SHORT),
        MEDIUM(DateFormat.MEDIUM, FormatStyle.MEDIUM),
        LONG(DateFormat.LONG, FormatStyle.LONG),
        FULL(DateFormat.FULL, FormatStyle.FULL);

        private final int dateFormat;

        private final FormatStyle formatStyle;

        private Style(int dateFormat, FormatStyle formatStyle){
            this.dateFormat = dateFormat;
            this.formatStyle = formatStyle;
        }

        public int getDateFormat() {
            return dateFormat;
        }

        public FormatStyle getFormatStyle() {
            return formatStyle;
        }
    }
}

其他方式

Tag Handler需要实现interface Tag或者SimpleTag，它们都是JspTag maker interface，前面的TagSupport实现了Tag。SimpleTag比较简单，但有个缺点，SimpleTag类创建，使用一次，然后丢弃，也就是更为消耗资源，但是可以很方便地使用循环，例子如下：

public void doTag() throws JspException, IOException{
    while(condition-is-true){
        this.getJspContext().setAttribute(“someElVariable”, value);
        //invoke()用于将body写到JSP的output。如果不是null，而是其他的Writer，则写到该writer中。
        this.getJspBody().invoke(null);
    }
}

如果我们采用IterationTag（是Tag的继承），则需要： 

public int doStartTag() throws JspException{
    //只唤醒1次。doStartTag()可以返回Tag.SKIP_BODY或Tag.EVAL_BODY_INCLUDE
    if(condition-is-true){
        this.pageContext.setAttribute(“someElVariable”, value);
        return Tag.EVAL_BODY_INCLUDE;
    }
    return Tag.SKIP_BODY;
}
public int doAfterBody() throws JspException{
    // 根据需要可唤醒多次，doAfterBody()可以返回Tag.SKIP_BODY或IterationTag.EVAL_BODY_AGAIN
    if(condition-is-true){
        this.pageContext.setAttribute(“someElVariable”, value);
        return Tag.EVAL_BODY_AGAIN; //再次执行body
    }
    return Tag.SKIP_BODY;
}
public int doEndTag() throws JspException{
    // 只唤醒1次，doEndTag()可以返回Tag.SKIP_PAGE或Tag.EVAL_PAGE
    return Tag.EVAL_PAGE;
}
  • SimpleTag用于不要求性能，不需要在池中重用实例，具体实现时通常继承SimpleTagSupport；
  • Tag除了循环获取body内容外，可以覆盖SimpleTag，具体实现通常继承TagSupport；
    • LoopTag是Tag的继承，不常用，主要用于对象如collection或者arrays的循环，具体实现通常继承LoopTagSupport；
    • IterationTag是Tag的集成，可以基于条件进行迭代，具体实现通常继承IterationTagSupport；
      • BodyTag继承IterationTag，允许输出缓存在一个BodyContent对象中，用作某种用途。在doStartTag()中返回 BodyTag.EVAL_BODY_BUFFERED而非Tag.EVAL_BODY_INCLUDE，并在doEndTag()中获取body内容。一般通过继承BodyTagSupport实现。

tld的EL function

定义function

我们在tld中增加两个function的定义，位于定义的后面。这两个function，一个使用现有的工具，一个要通过代码实现。

    ...... 前略 ......
    </tag>

    <!-- 第一个function，我们直接利用StringUtils提供的方法StringUtils.abbreviate(String,int)来实现。-->
    <function>
        <description>
            Abbreviates a string using ellipses (...) if the string is too long.
            The string parameter is the string to shorten, the int parameter is
            the maximum length the string should be, after which it will be
            shortened.
        </description>
        <name>abbreviateString</name>
        <function-class>org.apache.commons.lang3.StringUtils</function-class>
        <function-signature>
            java.lang.String abbreviate(java.lang.String,int)
        </function-signature>
    </function>

    <!-- 第一个function，我们将通过自己的代码实现。-->
    <!-- 类为cn.wei.flowingflying.chapter08.TimeUtils，静态方法为intervalToString(long)-->
    <function>
        <description>
            Formats a time interval in an attractive way, such as "less than one
            second" or "ten seconds" or "about 12 minutes".
        </description>
        <name>timeIntervalToString</name>
        <function-class>cn.wei.flowingflying.chapter08.TimeUtils</function-class>
        <function-signature>
            java.lang.String intervalToString(long)
        </function-signature>
    </function>
</taglib>

代码实现

public class TimeUtils {
	public static String intervalToString(long timeInterval){
		if(timeInterval < 1_000)
			return "less than one second";
		if(timeInterval < 60_000)
			return (timeInterval / 1_000) + " seconds";
		return "about " + (timeInterval / 60_000) + " minutes";
	}
}

EL使用function

例子中，我们使用了之前的template的tag。

<%--@elvariable id="myText" type="java.lang.String"--%>
<%@ taglib prefix="wei" uri="http://www.flowingflying.wei.cn/jsp/tld/wei" %>
<%@ taglib prefix="template" tagdir="/WEB-INF/tags/template" %>
<template:main htmlTitle="Abbreviating Text">
   <b>Text:</b> ${wei:abbreviateString(myText, 32)}<br />
</template:main>

使用tag

结合之前的template，jsp的代码如下：

<%--@elvariable id="date" type="java.util.Date"--%>
<%--@elvariable id="calendar" type="java.util.Calendar"--%>
<%--@elvariable id="instant" type="java.time.Instant"--%>
<%@ taglib prefix="template" tagdir="/WEB-INF/tags/template" %>
<%@ taglib prefix="wei" uri="http://www.flowingflying.wei.cn/jsp/tld/wei" %>

<template:main htmlTitle="Displaying Dates Properly">
    <b>Date:</b>
    <wei:formatDate value="${date}" type="both" dateStyle="full" timeStyle="full" /><br />

    <b>Date, time first with separator:</b>
    <wei:formatDate value="${date}" type="both" dateStyle="full" timeStyle="full" timeFirst="true" 
        separateDateTimeWith=" on " /><br />
    <hr>
    <b>Calendar:</b>
    <wei:formatDate value="${calendar}" type="both" dateStyle="full" timeStyle="full" /><br />
       
    <hr>
    <b>Instant:</b>
    <wei:formatDate value="${instant}" type="both" dateStyle="full" timeStyle="full" /><br />
       
    <b>Instant, time first with separator:</b>
    <wei:formatDate value="${instant}" type="both" dateStyle="full" timeStyle="full" timeFirst="true"
        separateDateTimeWith=" 于 " /><br />
</template:main>


相关链接： 我的Professional Java for Web Applications相关文章

恺风
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java的tag标签教程
12-16
Java的tag标签教程，可以不用写类就封装代码，方便网站及BS系统不用重启服务器修改程序。
JSP自定义标签学习笔记
08-11
本篇学习笔记将深入探讨JSP自定义标签的相关概念、创建方法以及实际应用。 一、概述 1.1 使用简单标签机制 JSP自定义标签提供了类似HTML标签的语法结构，通过自定义标签，开发者可以封装复杂的Java代码，使得页面...
java tag文件_Tag文件使用
weixin_31792645的博客
02-16 931
Tag文件和JSP文件很类似,可以被JSP文件动态加载调用,但是用户不能直接访问.Tag文件的存储目录:Tag文件规定放在/WEB-INF/tags目录或其子目录下,文件名随意.Tag文件的使用:Tag指令:1.body-content 属性:设置Tag标记标记体的情况.可取的值:tagdependent：标签体内容直接被写入BodyContent，由自定义标签类来进行处理，而不被JSP容器解释....
java web配置自定义标签及tld的多种配置方式与EL表达式，JSTL说明
qq_30021219的博客
01-14 741
java web配置自定义标签及tld的多种配置方式与JSTL说明
java tag文件,JSP中Tag文件与Tag标记
weixin_33096511的博客
03-13 1571
引入原因多个JSP页面的共用信息可以放在一个单独JSP文件中，然后用Include指令或动作载入，实现代码复用。缺点是用户可以直接访问这些JSP文件(我们可能不希望用户访问)，且include载入的文件可以放在任意目录中，目录显得杂乱不利维护。解决方法：引入Tag文件。它是一种特殊的文本文件，扩展名为.tag，和JSP文件很类似，可以被JSP页面动态加载调用，但是用户不能通过该Tag文件所在Web...
java web开发——Tag文件与Tag标记
g4443630的博客
05-08 1080
本章主要是对tag文件以及tag标记的介绍，包含tag文件的常用指令等。
freemaker学习笔记
01-10
4. `power.tld`：TLD（Tag Library Descriptor）文件是JSP标签库的描述文件，可能包含了自定义的FreeMarker标签定义。 5. `power.ui.service.xml`：此文件可能是Struts2的配置文件，定义了服务组件或者与UI相关的...
java学习笔记
01-04
Java学习笔记涵盖了从基础到进阶的多个Java技术知识点，主要集中在J2EE、JSP、Servlet和数据库交互等方面。以下是对这些知识点的详细说明： 1. **J2EE**：Java 企业版（Java 2 Platform, Enterprise Edition，简称...
jstl 标签的jar tld 笔记 自己学习了 希望对你有帮助
06-16
JSTL（JavaServer Pages Standard Tag Library，JavaServer Pages 标准标签库）是Java Web开发中的一种重要工具，它为JSP页面提供了一系列预定义的标签，简化了页面逻辑，使得代码更加清晰易读。TLD（Tag Library ...
j2ee学习笔记-j2ee学习笔记
09-14
**J2EE学习笔记概述** J2EE（Java 2 Platform, Enterprise Edition）是一个由Sun Microsystems（现已被Oracle收购）开发的平台，主要用于构建企业级的分布式应用系统。它提供了服务器端组件模型、服务和API，支持...
Java自定义标签开发Tag和tld开发
12-20
Java自定义标签开发Tag和tld开发,非常详细的哟
spring tags文件spring.tld
10-20
http://www.springframework.org/tags所需要的tld文件
Java_JSP2_标签文件Tag File支持；
cyb专栏
11-03 934
Tag File是自定义标签的简化用法，使用TagFile可以无须定义标签处理类和标签库文件，但仍然可以在JSP页面中使用自定义标签；  Tag File示例：迭代器标签  (1)、建立Tag文件  Tag File所具有的5编译指令：taglib，导入其他标签库；include，导入其他jsp或静态页面；tag，类似JSP中的page指令，有pageEncoding、body-conten
TLD&TAG
xiaojiavm的专栏
03-17 556
在jsp文件中，可以引用tag和tld文件。 1.对于tag文件 其中的tags是个目录，里面有若干tag文件。 但使用时，目录WEB-INF/tags下，必然有个XXXX.tag文件与之对应。 2.对于tld文件 在jsp中可以引用TLD文件，如 http://struts.apache.org/tags-html" prefix="html"%> 但是这个ht
java tag文件,自定义Tag文件封装步骤与示例
weixin_39753747的博客
03-13 159
相同的颜色就是对应的名称。1.在项目WebRoot/WEB_INF,下新建 HtmlTag.tld 文件 1.0 1.1 yaohttp://com.yao/tags/htmlTextTag com.util.tag.html.TextTag //对应的java文件路径 emptyproperty false true2.java类继承：BodyTagSupport类, 覆写方法：doTagSt...
Attribute [id] invalid for tag [iterator] according to TLD
最新发布
weixin_47246285的博客
05-16 230
Attribute [id] invalid for tag [iterator] according to TLD
那些年踩过的坑
weixin_34205826的博客
10-12 240
---------------------------------------------------------------------------------------------[版权申明：本文系作者原创，转载请注明出处]文章出处：http://blog.csdn.net/sdksdk0/article/details/52801484作者：朱...
iterator标签用begin属性报错:Attribute begin invalid for tag iterator according to TLD
iteye_6988的博客
11-12 438
 iterator 标签用bgin 属性报错Attribute begin invalid for tag iterator according to TLD   原因： struts2的iterator 标签在2.0版本没用begin属性，在2,1,8版本里有   解决方案： 1、更换高版本的struts2 2、不更换可以通过status属性的index方法来控制。 比如： ...
taglib和自定义标签的开发之tld文件
幽默工作室
10-25 3669
这表示是指令，主要用来提供整个JSP 网页相关的信息，并且用来设定JSP网页的相关属性， 例如：网页的编码方式、语法、信息等。 起始符号为： <%@ 终止符号为： %> 目前有三种写到内的指令：page、include 和taglib，每一种指令都有各自的属性。 page 指令是最复杂的JSP指令，它的主要功能为设定整个JSP 网页的属性和相关功能。 include 指令表示：在JSP 编译时插入
J2EE程序设计5.ppt
11-23
J2EE程序设计5.ppt

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值