方寸心间

原理：

    我们先把树按照水平方式摆开。从根节点开始（“Food”），然后他的左边写上1。然后按照树的顺序（从上到下）给“Fruit”的左边写上2。这样，你沿着树的边界走啊走（这就是“遍历”），然后同时在每个节点的左边和右边写上数字。最后，我们回到了根节点“Food”在右边写上18。下面是标上了数字的树，同时把遍历的顺序用箭头标出来了。

    我们称这些数字为左值和右值（如，“Food”的左值是1，右值是18）。正如你所见，这些数字按时了每个节点之间的关系。因为“Red”有3和6两个值，所以，它是有拥有1-18值的“Food”节点的后续。同样的，我们可以推断所有左值大于2并且右值小于11的节点，都是有2-11的“Fruit” 节点的后续。这样，树的结构就通过左值和右值储存下来了。这种数遍整棵树算节点的方法叫做“改进前序遍历树”算法。

表结构设计：

常用的操作：

下面列出一些常用操作的SQL语句

返回完整的树（Retrieving a Full Tree）

SELECT node.name
  FROM nested_category node, nested_category parent
 WHERE node.lft BETWEEN parent.lft AND parent.rgt
   AND parent.name = 'electronics'
 ORDER BY node.lft

返回某结点的子树（Find the Immediate Subordinates of a Node）

SELECT V.*
  FROM (SELECT node.name,
               (COUNT(parent.name) - (AVG(sub_tree.depth) + 1)) depth
          FROM nested_category node,
               nested_category parent,
               nested_category sub_parent,
               (SELECT V.*
                  FROM (SELECT node.name, (COUNT(parent.name) - 1) depth
                          FROM nested_category node, nested_category parent
                         WHERE node.lft BETWEEN parent.lft AND parent.rgt
                           AND node.name = 'portable electronics'
                         GROUP BY node.name) V,
                       nested_category T
                 WHERE V.name = T.name
                 ORDER BY T.lft) sub_tree
         WHERE node.lft BETWEEN parent.lft AND parent.rgt
           AND node.lft BETWEEN sub_parent.lft AND sub_parent.rgt
           AND sub_parent.name = sub_tree.name
         GROUP BY node.name) V,
       nested_category T
 WHERE V.name = T.name
   and V.depth <= 1
   and V.depth > 0
 ORDER BY T.Lft

返回某结点的祖谱路径（Retrieving a Single Path）

SELECT parent.name
  FROM nested_category node, nested_category parent
 WHERE node.lft BETWEEN parent.lft AND parent.rgt
   AND node.name = 'flash'
 ORDER BY node.lft

返回所有节点的深度（Finding the Depth of the Nodes）

SELECT V.*
  FROM (SELECT node.name, (COUNT(parent.name) - 1) depth
          FROM nested_category node, nested_category parent
         WHERE node.lft BETWEEN parent.lft AND parent.rgt
         GROUP BY node.name) V,
       nested_category T
 WHERE V.name = T.name
 ORDER BY T.Lft

返回子树的深度（Depth of a Sub-Tree）

SELECT V.*
  FROM (SELECT node.name,
               (COUNT(parent.name) - (AVG(sub_tree.depth) + 1)) depth
          FROM nested_category node,
               nested_category parent,
               nested_category sub_parent,
               (SELECT V.*
                  FROM (SELECT node.name, (COUNT(parent.name) - 1) depth
                          FROM nested_category node, nested_category parent
                         WHERE node.lft BETWEEN parent.lft AND parent.rgt
                           AND node.name = 'portable electronics'
                         GROUP BY node.name) V,
                       nested_category T
                 WHERE V.name = T.name
                 ORDER BY T.lft) sub_tree
         WHERE node.lft BETWEEN parent.lft AND parent.rgt
           AND node.lft BETWEEN sub_parent.lft AND sub_parent.rgt
           AND sub_parent.name = sub_tree.name
         GROUP BY node.name) V,
       nested_category T
 WHERE V.name = T.name
 ORDER BY T.Lft

返回所有的叶子节点（Finding all the Leaf Nodes）

SELECT name FROM nested_category WHERE rgt = lft + 1

插入节点（Adding New Nodes）

LOCK TABLE nested_category WRITE;

SELECT @myRight := rgt FROM nested_category WHERE name = 'TELEVISIONS';

UPDATE nested_category SET rgt = rgt + 2 WHERE rgt > @myRight;
UPDATE nested_category SET lft = lft + 2 WHERE lft > @myRight;

INSERT INTO nested_category
  (name, lft, rgt)
VALUES
  ('GAME CONSOLES', @myRight + 1, @myRight + 2);

UNLOCK TABLES;

删除节点（Deleting Nodes）

LOCK TABLE nested_category WRITE;

SELECT @myLeft := lft, @myRight := rgt, @myWidth := rgt - lft + 1
  FROM nested_category
 WHERE name = 'GAME CONSOLES';

DELETE FROM nested_category WHERE lft BETWEEN @myLeft AND @myRight;

UPDATE nested_category SET rgt = rgt - @myWidth WHERE rgt > @myRight;
UPDATE nested_category SET lft = lft - @myWidth WHERE lft > @myRight;

UNLOCK TABLES;

二.

1.action配置 

按照第一篇中的配置，设置locator为action，则默认一个类的命名空间为： 
类路径                                     命名空间 
com.example.action.MainAction       ->    / 
com.example.action.products.Display ->    /products 
完整url为： 
类路径                                                  完整url 
com.example.action.MainAction                       -> /main 
com.example.action.products.Display                 -> /products/display 
com.example.action.company.ShowCompanyDetailsAction -> /company/details/show_company_details 



3.action类写法 
如果要实现基本零配置，命名空间和action名称按照默认的类路径搜索。默认执行方法是execute。方法返回值是success，就会找。 

Java代码 
package com.example.action;   
  
import com.opensymphony.xwork2.ActionSupport;   
  
public class HelloWorld extends ActionSupport {   
  
    private String message;   
  
    public String getMessage() {   
        return message;   
    }   
  
    public String execute() {   
        message = "Hello World! excute";   
        return SUCCESS;   
    }   
  
    public String edit() {   
            message = "Hello World! edit";   
        return "xyz";   
    }   
  
    public String delete() {   
        message = "Hello World! delete";   
        return "depp";   
    }   
  
}  

返回结果对应： 
类路径                                   实际url(WEB-INF/pages) 
/hello_world                            /hello_world.jsp或/hello_world_success.jsp 
/hello_world!edit                       /hello_world_xyz.jsp 
/hello_world!delete                     /hello_world_depp.jsp 
基本的零配置就是这样，如果要有redirect、chain等跳转方式，interceptor的配置，就要加入annotation。 


2.action类中的annotation 

convention插件的annotation都在annotation这个包中，基本和xml配置相对应。 
annotation           意义                                      作用域 
ParentPackage   指定继承的包(struts2)名                          包，类 
Namespaces      给一个action指定多个命名空间(一般不用)              包，类 
Namespace       指定一个命名空间(一般不用，按默认的类路径即可)         包，类，Namespaces注解中 
actions         给一个action指定多个名称                          方法 
action          指定一个action名称                               类，方法，actions注解中 
InterceptorRefs 一组拦截器集合(只能是名称，必须先在xml文件中配置好)    类，action注解中  
InterceptorRef  一个拦截器                                      类，InterceptorRefs注解中 
ResultPath      结果映射的路径(已经在struts.xml文件中指定)          包，类 
Results         多个结果集合                                     类，action注解中 
Result          一个结果定义                                     类，Results注解中 

需要注意： 

1）包(java)级别是在package-info.java这个文件中配置，可以配置整个包的定义，但是命名空间就不能按默认的类路径扫描了，必须也要显式的配置。所以这个文件最好不要使用。 

2）不在包(java)级别配置就要在类(java)级别配置，可能每个类都要写一句ParentPackage，指定继承的包(struts2)，以获得父包中的拦截器配置及其他公用配置。如果没有特殊的拦截器配置则不用配置ParentPackage。 

3）最好把annotation配到类级别，因为这样action名称及命名空间都可用默认的类路径扫描，不用我们显式的配置。只要配置特殊的result和拦截器即可。类中的其他方法使用动态方法调用的方式使用同一个配置。我们知道struts2所有配置都是启动加载到map中的，减少配置，会提高一定性能。而动态方法这种模式是零配置必不可少的，但我很不喜欢叹号出现在地址栏中，所以在后面的文章中我会结合restful插件及自己修改源代码实现意义上的动态方法调用，但形式上是别的方式，地址栏会比较美观。 

Java代码 
package com.example.action;   
  
import com.opensymphony.xwork2.ActionSupport;   
import org.apache.struts2.convention.annotation.Result;   
import org.apache.struts2.convention.annotation.Results;   
import org.apache.struts2.convention.annotation.InterceptorRef;   
import org.apache.struts2.convention.annotation.InterceptorRefs;   
  
@InterceptorRefs({   
    @InterceptorRef("interceptor-1"),   
    @InterceptorRef("defaultStack")   
})   
@Results({   
    @Result(name="reload",location="hello_world",type="redirectAction",params={key1,value1,key2,value2}),   
    @Result(name="chainact",location="hello_world!edit",type="chain")   
})   
public class HelloWorld extends MyBaseAction {   
  
    private String message;   
  
    public String getMessage() {   
        return message;   
    }   
  
    public String execute() {   
        message = "Hello World! excute";   
        return SUCCESS;   
    }   
  
    public String edit() {   
            message = "Hello World! edit";   
        return RELOAD;   
    }   
           
    public String delete() {   
            message = "Hello World! delete";   
        return CHAINACT;   
    }   
}  

4）如果有极其特殊的情况需要为action的每个方法单独配置，这时就不能用默认的类扫描了，必须是先配置action，指定名称，再在action中配置result和interceptor。这就会使配置增多，违背的零配置的初衷。有时我们为了性能原因想把拦截器细化到具体的action上，我想如果真是这样，我们还不如再写一个action类。还有struts2.1.6原有的配置是如果action名称中有“/”，会认为这是一个命名空间，不会再按照类扫描的默认值。例如： 

Java代码 
package com.example.action;   
  
import com.opensymphony.xwork2.ActionSupport;   
import org.apache.struts2.convention.annotation.Action;   
  
public class HelloWorld extends ActionSupport {   
  
    @Action("/different/url")   
    public String execute() {   
        return SUCCESS;   
    }   
  
    @Action("url")   
    public String doSomething() {   
        return SUCCESS;   
    }   
}  

    调用方法execute的url为 :       /different/url (命名空间已经更换) 
    调用方法doSomething的url为 :   /url 

5）比较别扭的地方就是拦截器的配置，必须用名称，而名称和实际拦截器类的对应关系是在struts.xml文件中声明的，如果用struts2以前的annotation是可以直接配置拦截器类的，但是我没有和convention插件结合使用，这个问题我正在研究，看看有没有好的办法。 

6）还有一种默认的chain跳转，实际是在struts2.1.6中新增的unknownHandleder中设定的，没有什么太大作用，我们可以不使用。而unknownHandleder我们可以自定义为其他，这在后面的文章中会有说明。 

三.

1.Convention插件的主要实现浅析

1.1  PackageBasedActionConfigBuilder 这个类最重要，是整个程序的入口。
     1.1.1  buildActionConfigs方法进行初始化配置，其中findActions扫描类路径，我没有深入研究这个方法具体是怎么找到所有类的。只是找到全部类后，和我们的配置文件中限定的范围匹配、过滤，存入一个set中。然后buildConfiguration(set)循环分析这些类。

     1.1.2  buildConfiguration方法，首先创建一个map类型的packageConfigs。键为包（struts2）名，值为PackageConfig.Builder对象，这个对象可以创建PackageConfig对象。
      然后循环找到的类，分析包名（java），determineActionNamespace方法分析命名空间，得到一个list对象。
      再循环所有命名空间，determineActionName方法分析类名称、类的默认方法（这个是写死在程序中的，就是execute方法）。
      getPackageConfig方法分析得到PackageConfig.Builder对象。
      getActionAnnotations方法分析得到action类方法的annotation配置。
      循环每个方法的配置，调用createActionConfig方法分析，把results，interceptors，exceptionMappings等配置放入ActionConfig.Builder对象，再把ActionConfig对象（由ActionConfig.Builder生成）放入PackageConfig.Builder中。
      buildIndexActions创建默认索引action。这个好像用处不大。
      最后把PackageConfig对象放入Configuration对象中，这是最顶级的配置。我们在任何时间和地点都可以得到Configuration对象，并对其进行分析。

     1.1.3   determineActionNamespace方法是确定一个action类在web应用中的命名空间，先找这个类的Namespace注解，找到后放入一个存储命名空间的list。再找Namespaces注解，一个action可以有多个命名空间。如果有注解则按照注解来确定一个action的命名空间，如果没有，则分析这个action所在包（java）的路径，按照struts2.xml中配置的规则来确定。这个规则就是截取到定义的locator，在这个locator之后的包（java）全部作为命名空间，类名作为action名称。

     1.1.4   determineActionName方法是确定一个action类在web应用中的名称。由ActionNameBuilder（接口）的方法来实现，这个接口的具体实现类，插件默认为SEOActionNameBuilder。被称为搜索引擎友好的名称。会把action类的name按单词分解，然后用连接符连起来。默认连接符是"-"，我们可以设置为"_"。

     1.1.5   getPackageConfig方法是确定一个action类在web应用中的继承的包（struts2）。先找这个类的ParentPackage注解，如果有注解则按照注解来确定一个action的父包（struts2），如果没有，按照struts.xml中配置的规则来确定。这个规则就是defaultParentPackage。得到父包（struts2）后要拼成： actionPackage + "#" + parentPkg.getName() + "#" + actionNamespace 的形式，这是xwork里的规定。

     1.1.6   getActionAnnotations方法是确定一个action类的方法上的annotation配置。先找方法的Actions注解，一个方法可以有多个action映射。再找Action注解，放入一个map中，键是方法名，值是存储一组acton映射的list对象。
    
      1.1.7   createActionConfig方法构造ActionConfig.Builder对象，逐一判断interceptors，results，exceptionMappings，都是从类一级开始判断是否有此注解，再从方法的action注解中寻找。InterceptorMapBuilder，ResultMapBuilder是两个接口，提供通过注解构造Interceptor和Result的方法，插件分别提供了默认的实现DefaultInterceptorMapBuilder和DefaultResultMapBuilder。而buildExceptionMappings只是本类中的一个方法。

1.2  DefaultInterceptorMapBuilder
     先找action类是否存在InterceptorRefs注解，再看是否存在InterceptorRef注解，再看action注解中是否定义了InterceptorRefs。
     还用到了StringTools的createParameterMap方法把注解中的params（形式为{key1,value1,key2,value2,......}）转化成一个map。
      buildInterceptorList方法利用了xwork中的InterceptorBuilder的一个静态方法constructInterceptorReference把拦截器注入到配置中。
      而一个action所继承的父包中的拦截器，或是默认拦截器，并不在这个类中构造。而是由xwork根据包（struts2）的继承关系加载（actionPackage + "#" + parentPkg.getName() + "#" + actionNamespace 这是xwork里规定的形式，已经由PackageBasedActionConfigBuilder 配置）。

1.3 DefaultResultMapBuilder
    1.3.1  build方法，确定defaultResultPath，构造包含ResultConfig的map对象，再通过扩展名获得一个包含ResultTypeConfig的map对象。createFromResources方法获得默认返回结果页面，然后查找action注解中的results配置，再找类级别的Results注解，再找类级别的Result注解，相同的肯定会覆盖。createFromAnnotations。

    1.3.2  createFromResources方法中使用servletContext.getResourcePaths方法寻找页面。如果struts.xml中配置flatLayout为true则直接找到以命名空间为名称的文件夹，在此文件夹中寻找页面，如果flatLayout为false，则会找到以命名空间为名称的文件夹，再找到此文件夹中的以action名称命名的子文件夹，在这个文件夹中寻找页面。

    1.3.3  makeResults方法找默认的返回页面，如果没有路径没有包含resultcode（定义的字符串）的页面，则按默认顺序寻找success，input，error。比如hello_world.jsp文件（flatLayout为true，连接符为"_"），如果没有hello_world_success.jsp，hello_world_input.jsp，hello_world_error.jsp文件，同时"success"，"input"，"error"，又没有显式的配置，只是作为结果字符串返回，则程序默认会用hello_world.jsp来匹配三种结果。如果结果字符串resultcode是"edit"，同时又没有显式的配置，则必会找hello_world_edit.jsp。

    1.3.4  createFromAnnotations这个方法就是把注解转换成ResultConfig配置。

1.4 ConventionsServiceImpl
    是result配置的辅助类。determineResultPath方法先判断struts.xml文件中的配置，再判断action类的注解中是否有ResultPath，如果有将覆盖struts.xml中配置。
     getResultTypesByExtension方法提供一个map对象，默认的result结果返回。

      其实通过看这些方法，我们也基本了解了struts2的整个配置过程，非常繁琐，很多的判断确实很耗费资源，使用xml配置也一样。我们也知道所有配置信息都是应用启动时加载，存入map中常驻内存。所以我们应该尽可能减少配置，多使用动态方法调用。

1.5  ConventionUnknownHandler 是UnknownHandler接口的一个实现，用来处理找不到相应配置的情况。在struts2.1的dtd中新增了一个<unknown-handler-stack>元素，可以配置一组handler。
       handleUnknownAction方法处理找不到action的情况。这个我感觉用处不大。
       handleUnknownResult方法处理找不到result的情况。这个方法可以有很多扩展。比如我想定义一种返回值形式：redirect->xxx.do?ad=12或chain->xxx.do。用这种形式比写注解要方便的多。
       handleUnknownActionMethod方法处理找不到action中方法的情况。这个默认没有实现。

准备:
1.apache-ant-1.7.0.
2.hibernate-3.2.1.ga.zip,HibernateTools-3.2.1.ga.zip.
3.数据库的jdbc驱动程序,我使用的是mysql,驱动程序为mysql-connector-java-5.1.6。

项目布置:
1.建立Project-Name文件夹,其下建立:config,java,schema,lib文件夹以及build.xml文件.
2.加入jar包:hibernate3.jar,hibernate-tools.jar,freemarker.jar,mysql-connector-java.jar,...
3.src/hibernate.cfg.xml:

4.src/your-package/Customer.hbm.xml:

5.build.xml:

unsaved-value是表示一个对象是新的还是旧的，当显式的使用session.save()或者session.update()操作一个对象的时候，实际上是用不到unsaved-value的。某些情况下(父子表关联保存)，当你在程序中并没有显式的使用save或者update一个持久对象，那么Hibernate需要判断被操作的对象究竟是一个已经持久化过的持久对象，是一个尚未被持久化过的内存临时对象。例如：

CODE:    
Session session = ;    
Transaction tx = ;    
Parent parent = (Parent) session.load(Parent.class, id);    
Child child = new Child();    
child.setParent(parent);    
child.setName("sun");    
parent.addChild(child);    
s.update(parent);    
s.flush();    
tx.commit();    
s.close();

在上例中，程序并没有显式的session.save(child); 那么Hibernate需要知道child究竟是一个临时对象，还是已经在数据库中有的持久对象。如果child是一个新创建的临时对象(本例中就是这种情况)，那么Hibernate应该自动产生session.save(child)这样的操作，如果child是已经在数据库中有的持久对象，那么Hibernate应该自动产生session.update(child)这样的操作。3^)N%Q(}z1U        Q$x
因此我们需要暗示一下Hibernate，究竟child对象应该对它自动save还是update。在上例中，显然我们应该暗示Hibernate对child自动save，而不是自动update。那么Hibernate如何判断究竟对child是save还是update呢？它会取一下child的主键属性 child.getId() ，这里假设id是 java.lang.Integer类型的。如果取到的Id值和hbm映射文件中指定的unsave-value相等，那么Hibernate认为child是新的内存临时对象，发送save，如果不相等，那么Hibernate认为child是已经持久过的对象，发送update。`_/Zw
mV-yWr
unsaved-value="null" (默认情况，适用于大多数对象类型主键 Integer/Long/String/...)
当Hibernate取一下child的Id，取出来的是null(在上例中肯定取出来的是null)，和unsaved-value设定值相等，发送save(child)
当Hibernate取一下child的id，取出来的不是null，那么和unsaved-value设定值不相等，发送update(child)
例如下面的情况：

CODE:    
Session session = ;    
Transaction tx = ;    
Parent parent = (Parent) session.load(Parent.class, id);    
Child child = (Child) session.load(Child.class, childId);    
child.setParent(parent);    
child.setName("sun");    
parent.addChild(child);    
s.update(parent);    
s.flush();    
tx.commit();    
s.close();

child已经在数据库中有了，是一个持久化的对象，不是新创建的，因此我们希望Hibernate发送update(child)，在该例中，Hibernate取一下child.getId()，和unsave-value指定的null比对一下，发现不相等，那么发送update(child)。
BTW: parent对象不需要操心，因为程序显式的对parent有load操作和update的操作，不需要Hibernate自己来判断究竟是save还是update了。我们要注意的只是child对象的操作。另外unsaved-value是定义在Child类的主键属性中的。

CODE:    
<class name="Child" table="child">    
"id" name="id" type="integer" unsaved-value="null">    
  class="identity"/>    
   
    
class>

如果主键属性不是对象型，而是基本类型，如int/long/double/...，那么你需要指定一个数值型的unsaved-value，
例如：

在此提醒大家，很多人以为对主键属性定义为int/long，比定义为Integer/Long运行效率来得高，认为基本类型不需要进行对象的封装和解构操作，因此喜欢把主键定义为int/long的。但实际上，Hibernate内部总是把主键转换为对象型进行操作的，就算你定义为int/long型的，Hibernate内部也要进行一次对象构造操作，返回给你的时候，还要进行解构操作，效率可能反而低也说不定。因此大家一定要扭转一个观点，在Hibernate中，主键属性定义为基本类型，并不能够比定义为对象型效率来的高，而且也多了很多麻烦，因此建议大家使用对象型的Integer/Long定义主键。
unsaved-value="none"和 悠忆社区/V,tq9fs
unsaved-value="any"
主要用在主键属性不是通过Hibernate生成，而是程序自己setId()的时候。www.yoy1.com#m4iCO'n\$T
在这里多说一句，强烈建议使用Hibernate的id generator，或者你可以自己扩展Hibernate的id generator，特别注意不要使用有实际含义的字段当做主键来用！例如用户类User，很多人喜欢用用户登陆名称做为主键，这是一个很不好的习惯，当用户类和其他实体类有关联关系的时候，万一你需要修改用户登陆名称，一改就需要改好几张表中的数据。偶合性太高，而如果你使用无业务意义的id generator，那么修改用户名称，就只修改user表就行了。
由这个问题引申出来，如果你严格按照这个原则来设计数据库，那么你基本上是用不到手工来setId()的，你用Hibernate的id generator就OK了。因此你也不需要了解当社会,体育,生活,情感,搞笑,JAVA技术交流,软件交流,IT资讯(r9j.@%u:s
@4k_7P,P
unsaved-value="none"和 社会,体育,生活,情感,搞笑,JAVA,struts,hibernate技术交流,软件交流,IT资讯t;P|_0R+vy,g)z6H
unsaved-value="any"社会,体育,生活,情感,搞笑,JAVA技术交流,软件交流,IT资讯7W'N0W9W'R\
究竟有什么含义了。如果你非要用assigned不可，那么继续解释一下：b i9d e1W[B
unsaved-value="none" 的时候，由于不论主键属性为任何值，都不可能为none，因此Hibernate总是对child对象发送update(child)社会,体育,生活,情感,搞笑,JAVA,struts,hibernate技术交流,软件交流,IT资讯 C5pm
x.o:o
unsaved-value="any" 的时候，由于不论主键属性为任何值，都肯定为any，因此Hibernate总是对child对象发送save(child)社会,体育,生活,情感,搞笑,JAVA技术交流,软件交流,IT资讯G.H#n&WK6WZYWB
大多数情况下，你可以避免使用assigned，只有当你使用复合主键的时候不得不手工setId()，这时候需要你自己考虑究竟怎么设置unsaved-value了，根据你自己的需要来定。
强烈不建议使用composite-id，强烈建议使用UserType。
因此，如果你在系统设计的时候，遵循如下原则：Y?GS*w
OKYw
1、使用Hibernate的id generator来生成无业务意义的主键，不使用有业务含义的字段做主键，不使用assigned。社会,体育,生活,情感,搞笑,JAVA,struts,hibernate技术交流,软件交流,IT资讯:EOs7Z$P"`6h
2、使用对象类型(String/Integer/Long/...)来做主键，而不使用基础类型(int/long/...)做主键社会,体育,生活,情感,搞笑,JAVA,struts,hibernate技术交流,软件交流,IT资讯\MJ%d\b
TI
3、不使用composite-id来处理复合主键的情况，而使用UserType来处理该种情况。
#yo9LLlU a
那么你永远用的是unsaved-value="null" ，不可能用到any/none/..了。