1.谁能简述下Struts中的标记库 要详解 ！！！！

Posted 2023-04-12

Struts标记库
JSP视窗组件所使用的struts标记库由四类标记组成：
2. Bean标记：用来在JSP页中管理bean
3. 逻辑标记：用来在JSP页中控制流程
4. html标记：用来生成HTML标记，在表单中显示数据，使用会话ID对URL进行编程
5. 模板标记：使用动态模板构造普通格式的页
2.1 Bean标记
这个标记库中包含用于定义新bean、访问bean及其属性的标记。Struts框架提供了多种自定义标记用来在JSP页中处理JavaBean。这些标记被封装在一个普通的标记库中，在文件struts-bean.tld中定义了它的标记库描述器。Bean标记库将标记定义在四个子类别中：
创建和复制bean的标记
脚本变量定义标记
bean翻译标记
消息国际化标记
2.1.1 Bean复制标记
可定义新bean，可复制现有bean，还可从现有bean复制属性。
<bean:define>标记用来：
定义新字符串常数
将现有的bean复制到新定义的bean对象
复制现有bean的属性来创建新的bean
<bean:define>标记属性：
属性描述Id 新定义的bean脚本变量名称，必须设置Type 定义引入脚本变量的类Value 为id属性定义的脚本变量分配一个新的对象Name 目标bean的名称。若value属性没有设置，这个属性就必须设置property Name属性定义的bean的属性名称，用来定义新的bean
13
Scope 源bean的作用域。若没有设置，搜索范围是从页作用域到应用程序作用域toScope 目标bean的作用域。若没有设置，默认值是页作用域
例如：定义一个bean:
<bean:define id=”test” value=”this is a test”/>
源bean在页作用域中被拷贝大哦请求作用域中的另一个bean:
<bean:define id=”targetBean” name=”sourceBean”
scope=”page” toScope=”request”/>
2.1.2 定义脚本变量的标记
从多种资源中定义和生成脚本变量，这些资源包括cookie,请求参数，HTTP标头等等。属性如下：
属性描述Id 脚本变量和要定义的页作用域属性的名称Name cookie/标头/参数的名称multiple 如果这个属性设置了任意一个数值，所有匹配的cookie都会被积累并存储到一个Cookie[](一个数组)类型的bean里。若无设置，指定cookie的第一个值将作为Cookie类型的值Value 如果没有匹配的cookie或数值，就返回这个属性指定的默认值
例如：
<bean:cookie id=”myCookie” name=”userName”/>
脚本变量名称是myCookie，用来创建这个属性的cookie的名称是userName。
<bean:header id=”myHeader” name=”Accept-Language”/>
脚本变量名称是myHeader,请求标头的名称是Accept-Language.
<bean:parameter id=”myParameter” name=”myParameter”>
脚本变量名称是myPatameter,它保存的请求参数的名称也是myParameter.
<bean:include>标记将对一个资源的响应进行检索，并引入一个脚本变量和字符串类型的页作用域属性。这个资源可以是一个页，一个ActionForward或一个外部URL。与<jsp:include>的不同是资源的响应被存储到一个页作用域的bean中，而不是写入到输出流。属性如下：
属性描述Id 脚本变量和要定义的页作用域属性的名称Page 一个内部资源forward 一个ActionForward Href 要包含的资源的完整URL
例如：
<bean:include id=”myInclude” page=”MyJsp?x=1”/>
脚本变量的名称是myInclude，要检索的响应来自资源MyJsp?x=1。
<bean:resource>标记将检索web应用中的资源，并引入一个脚本变量和InputStream或字符串类型的页作用域属性。如果在检索资源时发生问题，就会产生一个请求时间异常。属性如下：
属性描述
14
Id 脚本变量和要定义的页作用域属性的名称Name 资源的相对路径Input 如果这个属性不存在，资源的类型就是字符串
例如：
<bean:resource id=”myResource” name=”/WEB-INF/images/myResource.xml”/>
脚本变量的名称是myResource，要检索的资源的名称是myResource.xml。
2.1.3 显示Bean属性
标记库中定义了<bean:write>标记，用来将bean的属性输送到封装的JSP页写入器。这个标记与<jsp:getProperty>类似，属性如下：
属性描述Name 要进行属性显示的bean的名称property 要显示的属性的名称。如果这个属性类有java.beans.PropertyEditor,getAsText()或toString 方法会被调用Scope Bean的作用域，若没有设置，搜索范围是从页到应用程序作用域Filter 如果设置true,属性中的所有特殊HTML字符都将被转化为相应的实体引用Ignore 如果设置false，当发现属性时会产生一个请求时间异常，否则返回null
例如：
<bean:write name=”myBean” property=”myProperty” scope=”request”
filter=”true”/>
myBean的属性myProperty将会被显示，作用域为请求，如果发现任何HTML特殊字符都将被转化为相应的实体引用。
2.1.4 消息标记和国际化
strtus框架支持国际化和本地化。用户在他们的计算机中定义自己所在的区域，当web应用程序需要输出一条消息时，它将引用一个资源文件，在这个文件中所有的消息都使用了适当的语言。一个应用程序可能提供了很多资源文件，每个文件提供了用不同语言编写的消息。如果没有找到所选语言的资源文件，就将使用默认的资源文件。
struts框架对国际化的支持是使用<bean:message>标记，以及使用java.util数据包中定义的Locale和ResourceBundle类来实现Java2平台对这些任务的支持。Java.text.MessageFormat类定义的技术可以支持消息的格式。利用此功能，开发人员不需了解这些类的细节就可进行国际化和设置消息的格式。
用strtus实现国际化和本地化：
第一步要定义资源文件的名称，这个文件会包含用默认语言编写的在程序中会出现的所有消息。这些消息以“关键字-值”的形式存储，如下：
error.validation.location = The entered location is invalid
这个文件需要存储在类的路径下，而且它的路径要作为初始化参数传送给ActionServlet作为参数进行传递时，路径的格式要符合完整Java类的标准命名规范。比如，如果资源文件存储在WEB-INFclasses目录中，文件名是
15
ApplicationResources.properties，那么需要传递的参数值是ApplicationResources。如果文件在WEB-INFclassescom est中，那么参数值就应该是com.test. ApplicationResources.
为了实现国际化，所有的资源文件必须都存储在基本资源文件所在的目录中。基本资源文件包含的是用默认地区语言-本地语言编写的消息。如果基本资源文件的名称是ApplicationResources.properties，那么用其他特定语言编写的资源文件的名称就应该是ApplicationResources_xx.properties(xx为ISO编码，如英语是en)。因此这些文件应包含相同的关键字，但关键字的值是用特定语言编写的。
ActionServlet的区域初始化参数必须与一个true值一起传送，这样ActionServlet就会在用户会话中的Action.LOCALE_KEY关键字下存储一个特定用户计算机的区域对象。现在可以运行一个国际化的web站点，它可以根据用户计算机上的设置的区域自动以相应的语言显示。
我们还可以使用特定的字符串来替换部分消息，就象用java.text.MessageFormat的方法一样：
error.invalid.number = The number is valid
我们可以把字符串替换成任何我们需要的数字。<bean:message>标签属性如下：
属性描述Key 资源文件中定义消息关键字Locale 用户会话中存储的区域对象的属性名称。若没有设置，默认值是Action.LOCALE_KEY Bundle 在应用程序上下文中，存储资源对象的属性的名称。如果没有设置这个属性，默认值是Action.MESSAGE_KEY arg0 第一个替换参数值arg1 第二个替换参数值arg2 第三个替换参数值arg3 第四个替换参数值
例如：资源文件中定义了一个消息：
info.myKey = The numbers entered are ,,,
我们可使用下面的消息标记：
<bean:message key=”info.myKey” arg0=”5” arg1=”6” arg2=”7” arg3=”8”/>
这个信息标记输出到JSP页会显示为：The numbers entered are 5,6,7,8
2.2 逻辑标记
逻辑库的标记能够用来处理外观逻辑而不需要使用scriptlet。Struts逻辑标签库包含的标记能够有条件地产生输出文本，在对象集合中循环从而重复地产生输出文本，以及应用程序流程控制。它也提供了一组在JSP页中处理流程控制的标记。这些标记封装在文件名为struts-logic.tld的标记包中。逻辑标记库定义的标记能够执行下列三个功能：
条件逻辑
重复
转发/重定向响应
16
2.2.1 条件逻辑
struts有三类条件逻辑。第一类可以比较下列实体与一个常数的大小：
cookie
请求参数
bean或bean的参数
请求标头
以下列出了这一类标记：
标记功能<equal> 如果常数与被定义的实体相等，返回true <notEqual> 如果常数与被定义的实体不相等，返回true <greaterEqual> 如果常数大于等于被定义的实体，返回true <lessEqual> 如果常数小于等于被定义的实体，返回true <lessThan> 如果常数小于被定义的实体，返回true <greaterThan> 如果常数大于被定义的实体，返回true
这一类的所有标记有相同的属性
属性描述Value 要进行比较的常数值Cookie 要进行比较的HTTP cookie的名称Header 要进行比较的HTTP请求标头的名称parameter 要进行比较的HTTP请求参数的名称Name 如果要进行比较的是bean或bean的属性，则这个属性代表bean的名称property 要进行比较的bean属性的名称Scope Bean的作用域，如果没有指定作用域，则它的搜索范围是从页到应用程序
例如：
<logic:equal parameter=”name” value=”SomeName”>
The entered name is SomeName
</logic:equal>
判断名为”name”的请求参数的值是否是”SomeName”。
<logic:greaterThan name=”bean” property=”prop” scope=”page” value=”7”>
The value of bean.Prop is greater than 7
</logic:greaterThan>
判断在页的作用域中是否有一个名为”bean”的bean，它有一个prop属性，这个属性的值是否大于7。如果这个属性能够转化为数值，就进行数值比较，否则就进行字符串比较。
第二类条件标记定义了两个标记：
<logic:present>
<logic:notPresent>
它们的功能是在计算标记体之前判断特定的项目是否存在。标记的属性和属性值决定了要进行检查的项目。
属性描述
17
Cookie 由这个属性指定的cookie将被检查是否存在Header 由这个属性指定的请求标头将被检查是否存在parameter 由这个属性指定的请求参数将被检查是否存在Name 如果没有设置property属性，那么有这个属性指定的bean将被检查是否存在。如果设置了，那么bean和bean属性都将被检查是否存在。property 检查有name属性指定的bean中是否存在指定的属性Scope 如果指定了bean的名称，这就是bean的作用域。如果没有指定作用域，搜索的范围从页到应用程序作用域。Role 检查当前已经确认的用户是否属于特殊的角色User 检查当前已经确认的用户是否有特定的名称
例如：
<logic:notPresent name=”bean” property=”prop” scope=”page”>
The bean property bean.prop is present
</logic:notPresent>
标记判断在页作用域中是否存在一个名为”bean”的bean，这个bean有一个prop属性。
第三类条件标记比较复杂，这些标记根据模板匹配的结果检查标记体的内容。换句话说，这些标记判断一个指定项目的值是否是一个特定常数的子字符串：
<logic:match>
<logic:notMatch>
这些标记允许JSP引擎在发现了匹配或是没有发现时计算标记主体。属性如下：
属性描述Cookie 要进行比较的HTTP cookie的名称Header 要进行比较的的HTTP标头的名称parameter 要进行比较的的HTTP请求参数的名称Name 若要对bean或bean的属性进行比较，这个属性是用户指定bean的名称location 如果设置了这个属性的值，将会在这个指定的位置(索引值)进行匹配scope 如果对bean进行比较，这个属性指定了bean的作用域。如果没有设置这个参数，搜索范围是从页到应用程序作用域property 要进行比较的bean的属性名称value 要进行比较的常数值
例如：
<logic:match parameter=”name” value=”xyz” location=”1”>
The parameter name is a sub-string of the string xyz from index 1
</logic:match>
标记检查名为”name”的请求参数是否是”xyz”的子字符串，但是子字符串必须从”xyz”的索引位置1开始（也就是说子字符串必须是”y”或”yz”）。 参考技术A 最简单的方式就是直接在jsp中用URI地址引用

<%@ taglib uri="/WEB-INF/struts-bean.tld" prefix="bean" %>
<%@ taglib uri="/WEB-INF/struts-html.tld" prefix="html" %>
<%@ taglib uri="/WEB-INF/struts-logic.tld" prefix="logic" %>

无须在web.xml中使用<taglib>配置uri映射

-------------------------
<jsp-config><taglib>..<taglib>/</jsp-config>是tomcat 5以上（j2ee2.4）的版本配置的方式

java提高篇-----详解匿名内部类 ,形参为什么要用final

   在java提高篇-----详解内部类中对匿名内部类做了一个简单的介绍，但是内部类还存在很多其他细节问题，所以就衍生出这篇博客。在这篇博客中你可以了解到匿名内部类的使用、匿名内部类要注意的事项、如何初始化匿名内部类、匿名内部类使用的形参为何要为final。

一、使用匿名内部类内部类

      匿名内部类由于没有名字，所以它的创建方式有点儿奇怪。创建格式如下：

new 父类构造器（参数列表）|实现接口（）  
    {  
     //匿名内部类的类体部分  
    }

      在这里我们看到使用匿名内部类我们必须要继承一个父类或者实现一个接口，当然也仅能只继承一个父类或者实现一个接口。同时它也是没有class关键字，这是因为匿名内部类是直接使用new来生成一个对象的引用。当然这个引用是隐式的。

public abstract class Bird {
    private String name;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
    
    public abstract int fly();
}

public class Test {
    
    public void test(Bird bird){
        System.out.println(bird.getName() + "能够飞 " + bird.fly() + "米");
    }
    
    public static void main(String[] args) {
        Test test = new Test();
        test.test(new Bird() {
            
            public int fly() {
                return 10000;
            }
            
            public String getName() {
                return "大雁";
            }
        });
    }
}
------------------
Output：
大雁能够飞 10000米

      在Test类中，test()方法接受一个Bird类型的参数，同时我们知道一个抽象类是没有办法直接new的，我们必须要先有实现类才能new出来它的实现类实例。所以在mian方法中直接使用匿名内部类来创建一个Bird实例。

     由于匿名内部类不能是抽象类，所以它必须要实现它的抽象父类或者接口里面所有的抽象方法。

      对于这段匿名内部类代码其实是可以拆分为如下形式：

public class WildGoose extends Bird{
    public int fly() {
        return 10000;
    }
    
    public String getName() {
        return "大雁";
    }
}

WildGoose wildGoose = new WildGoose();
test.test(wildGoose);

       在这里系统会创建一个继承自Bird类的匿名类的对象，该对象转型为对Bird类型的引用。

      对于匿名内部类的使用它是存在一个缺陷的，就是它仅能被使用一次，创建匿名内部类时它会立即创建一个该类的实例，该类的定义会立即消失，所以匿名内部类是不能够被重复使用。对于上面的实例，如果我们需要对test()方法里面内部类进行多次使用，建议重新定义类，而不是使用匿名内部类。

二、注意事项

      在使用匿名内部类的过程中，我们需要注意如下几点：

      1、使用匿名内部类时，我们必须是继承一个类或者实现一个接口，但是两者不可兼得，同时也只能继承一个类或者实现一个接口。

     2、匿名内部类中是不能定义构造函数的。

     3、匿名内部类中不能存在任何的静态成员变量和静态方法。

      4、匿名内部类为局部内部类，所以局部内部类的所有限制同样对匿名内部类生效。

     5、匿名内部类不能是抽象的，它必须要实现继承的类或者实现的接口的所有抽象方法。

三、使用的形参为何要为final

      参考文件：http://android.blog.51cto.com/268543/384844

       我们给匿名内部类传递参数的时候，若该形参在内部类中需要被使用，那么该形参必须要为final。也就是说：当所在的方法的形参需要被内部类里面使用时，该形参必须为final。

      为什么必须要为final呢？

      首先我们知道在内部类编译成功后，它会产生一个class文件，该class文件与外部类并不是同一class文件，仅仅只保留对外部类的引用。当外部类传入的参数需要被内部类调用时，从java程序的角度来看是直接被调用：

public class OuterClass {
    public void display(final String name,String age){
        class InnerClass{
            void display(){
                System.out.println(name);
            }
        }
    }
}

      从上面代码中看好像name参数应该是被内部类直接调用？其实不然，在java编译之后实际的操作如下：

public class OuterClass$InnerClass {
    public InnerClass(String name,String age){
        this.InnerClass$name = name;
        this.InnerClass$age = age;
    }
    
    
    public void display(){
        System.out.println(this.InnerClass$name + "----" + this.InnerClass$age );
    }
}

      所以从上面代码来看，内部类并不是直接调用方法传递的参数，而是利用自身的构造器对传入的参数进行备份，自己内部方法调用的实际上时自己的属性而不是外部方法传递进来的参数。

      直到这里还没有解释为什么是final？在内部类中的属性和外部方法的参数两者从外表上看是同一个东西，但实际上却不是，所以他们两者是可以任意变化的，也就是说在内部类中我对属性的改变并不会影响到外部的形参，而然这从程序员的角度来看这是不可行的，毕竟站在程序的角度来看这两个根本就是同一个，如果内部类该变了，而外部方法的形参却没有改变这是难以理解和不可接受的，所以为了保持参数的一致性，就规定使用final来避免形参的不改变。

      简单理解就是，拷贝引用，为了避免引用值发生改变，例如被外部类的方法修改等，而导致内部类得到的值不一致，于是用final来让该引用不可改变。

      故如果定义了一个匿名内部类，并且希望它使用一个其外部定义的参数，那么编译器会要求该参数引用是final的。

四、匿名内部类初始化

我们一般都是利用构造器来完成某个实例的初始化工作的，但是匿名内部类是没有构造器的！那怎么来初始化匿名内部类呢？使用构造代码块！利用构造代码块能够达到为匿名内部类创建一个构造器的效果。

public class OutClass {
    public InnerClass getInnerClass(final int age,final String name){
        return new InnerClass() {
            int age_ ;
            String name_;
            //构造代码块完成初始化工作
            {
                if(0 < age && age < 200){
                    age_ = age;
                    name_ = name;
                }
            }
            public String getName() {
                return name_;
            }
            
            public int getAge() {
                return age_;
            }
        };
    }
    
    public static void main(String[] args) {
        OutClass out = new OutClass();
        
        InnerClass inner_1 = out.getInnerClass(201, "chenssy");
        System.out.println(inner_1.getName());
        
        InnerClass inner_2 = out.getInnerClass(23, "chenssy");
        System.out.println(inner_2.getName());
    }
}