JavaWeb开发与代码的编写(十三)
EL表达式
EL 全名为Expression Language。EL主要作用： 1、获取数据 EL表达式主要用于替换JSP页面中的脚本表达式，以从各种类型的web域 中检索java对象、获取数据。(某个web域 中的对象，访问javabean的属性、访问list集合、访问map集合、访问数组) 2、执行运算 利用EL表达式可以在JSP页面中执行一些基本的关系运算、逻辑运算和算术运算，以在JSP页面中完成一些简单的逻辑运算。${user==null} 3、获取web开发常用对象 EL 表达式定义了一些隐式对象，利用这些隐式对象，web开发人员可以很轻松获得对web常用对象的引用，从而获得这些对象中的数据。 4、调用Java方法 EL表达式允许用户开发自定义EL函数，以在JSP页面中通过EL表达式调用Java类的方法。
获取数据
使用EL表达式获取数据语法："${标识符}" EL表达式语句在执行时，会调用pageContext.findAttribute方法，用标识符为关键字，分别从page、request、session、application四个域中查找相应的对象，找到则返回相应对象，找不到则返回”” （注意，不是null，而是空字符串）。
EL表达式可以很轻松获取JavaBean的属性，或获取数组、Collection、Map类型集合的数据
el表达式获取数据范例：
1
2
3
4
5
6
7
8 el表达式获取数据
9
10
11
12
15
16 使用EL表达式获取数据：${name}
17
18
19
24 使用el表达式可以获取bean的属性：${person.age}
25
26
27
34 ${person.address.name}
35
36
37
50
51
52 ${list[1].name}
53
54
55
56 ${person.name}
57
58
59
60
68
69
70 ${map.c}
71 ${map["1"]}
72
73
74
75 ${me.key}=${me.value}
76
77
78
79 运行效果如下：
执行运算
语法：${运算表达式}，EL表达式支持如下运算符：
1、关系运算符
2、逻辑运算符：
3、empty运算符：检查对象是否为null(空)
4、二元表达式：${user!=null?user.name :""} 5、[ ] 和 . 号运算符 使用EL表达式执行运算范例：
1
2
3
4
5
6
7 el表达式运算符
8
9
10
11 el表达式进行四则运算：
12 加法运算：${365+24}
13 减法运算：${365-24}
14 乘法运算：${365*24}
15 除法运算：${365/24}
16
17 el表达式进行关系运算：
18
19 ${user == null}
20 ${user eq null}
21
22 el表达式使用empty运算符检查对象是否为null(空)
23
30
31
32
33 ${str}
34
35
36
37
40
41
42 对不起，没有您想看的数据
43
44
45
46
47 EL表达式中使用二元表达式
48
51 ${user==null? "对不起，您没有登陆 " : user.username}
52
53
54
55 EL表达式数据回显
56
62 男
63 女
64 65
66 运行结果如下：
获得web开发常用对象
EL表达式语言中定义了11个隐含对象，使用这些隐含对象可以很方便地获取web开发中的一些常见对象，并读取这些对象的数据。 语法：${隐式对象名称}：获得对象的引用
测试EL表达式中的11个隐式对象：
1
2
3
4
5 el隐式对象
6
7
8
9 ---------------1、pageContext对象：获取JSP页面中的pageContext对象------------------------
10 ${pageContext}
11 ---------------2、pageScope对象：从page域(pageScope)中查找数据------------------------
12
15 ${pageScope.name}
16 ---------------3、requestScope对象：从request域(requestScope)中获取数据------------------------
17
20 ${requestScope.name}
21 ---------------4、sessionScope对象：从session域(sessionScope)中获取数据------------------------
22
25 ${sessionScope.user}
26 ---------------5、applicationScope对象：从application域(applicationScope)中获取数据------------------------
27
30 ${applicationScope.user}
31 --------------6、param对象：获得用于保存请求参数map，并从map中获取数据------------------------
32
33 ${param.name}
34
35
36
37
38
39 --------------7、paramValues对象：paramValues获得请求参数 //map{"",String[]}------------------------
40
41 ${paramValues.like[0]}
42 ${paramValues.like[1]}
43 --------------8、header对象：header获得请求头------------------------
44 ${header.Accept}
45
48 ${header["Accept-Encoding"]}
49 --------------9、headerValues对象：headerValues获得请求头的值------------------------
50
53 ${headerValues.Accept[0]}
54
58 ${headerValues["Accept-Encoding"][0]}
59 --------------10、cookie对象：cookie对象获取客户机提交的cookie------------------------
60
61 ${cookie.JSESSIONID.value} //保存所有cookie的map
62 --------------11、initParam对象：initParam对象获取在web.xml文件中配置的初始化参数------------------------
63
65
74
75 ${initParam.xxx}
76 ${initParam.root}
77
78 RegisterServlet的代码如下：
package me.gacl.web.controller;
import java.io.IOException;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
public class RegisterServlet extends HttpServlet {
/*
* 处理用户注册的方法
*/
public void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
//1、接收参数
String userName = request.getParameter("username");
/**
* 2、直接跳转回/ELDemo03.jsp页面，没有使用request.setAttribute("userName", userName)将userName存储到request对象中
* 但是在ELDemo03.jsp页面中可以使用${param.username}获取到request对象中的username参数的值
*/
request.getRequestDispatcher("/ELDemo03.jsp").forward(request, response);
}
public void doPost(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
doGet(request, response);
}
}测试结果如下：
注意: 测试header和headerValues时，如果头里面有“-” ，例Accept-Encoding，则要header["Accept-Encoding"]、headerValues["Accept-Encoding"] 测试cookie时，例${cookie.key}取的是cookie对象，如访问cookie的名称和值，须${cookie.key.name}或${cookie.key.value}
使用EL调用Java方法
EL表达式语法允许开发人员开发自定义函数，以调用Java类的方法。语法：${prefix：method(params)} 在EL表达式中调用的只能是Java类的静态方法，这个Java类的静态方法需要在TLD文件中描述，才可以被EL表达式调用。 EL自定义函数用于扩展EL表达式的功能，可以让EL表达式完成普通Java程序代码所能完成的功能。
EL Function开发步骤
一般来说， EL自定义函数开发与应用包括以下三个步骤： 1、编写一个Java类的静态方法 2、编写标签库描述符（tld）文件，在tld文件中描述自定义函数。 3、在JSP页面中导入和使用自定义函数
示例：开发对html标签进行转义的el function
1、编写html转义处理工具类，工具类中添加对html标签进行转义的静态处理方法，如下：
3 /**
4 * @ClassName: HtmlFilter
5 * @Description: html转义处理工具类
8 *
9 */
10 public class HtmlFilter {
11
12 /**
13 * @Method: filter
14 * @Description: 静态方法，html标签转义处理
17 * @param message 要转义的内容
18 * @return 转义后的内容
19 */
20 public static String filter(String message) {
21
22 if (message == null)
23 return (null);
24
25 char content[] = new char[message.length()];
26 message.getChars(0, message.length(), content, 0);
27 StringBuffer result = new StringBuffer(content.length + 50);
28 for (int i = 0; i < content.length; i++) {
29 switch (content[i]) {
30 case '':
34 result.append(">");
35 break;
36 case '&':
37 result.append("&");
38 break;
39 case '"':
40 result.append(""");
41 break;
42 default:
43 result.append(content[i]);
44 }
45 }
46 return (result.toString());
47 }
48 }2、在WEB-INF目录下编写标签库描述符（tld）文件，在tld文件中描述自定义函数
elFunction.tld的代码如下：
1.0
EL Function
/ELFunction
html标签转义处理方法
filter
me.gacl.util.HtmlFilter
java.lang.String filter(java.lang.String)
3、在JSP页面中导入和使用自定义函数
使用EL调用Java方法
${fn:filter("点点")}
运行结果如下：
开发EL Function注意事项
编写完标签库描述文件后，需要将它放置到\WEB-INF目录中或WEB-INF目录下的除了classes和lib目录之外的任意子目录中。 TLD文件中的 元素用指定该TLD文件的URI，在JSP文件中需要通过这个URI来引入该标签库描述文件。 元素用于描述一个EL自定义函数，其中： 子元素用于指定EL自定义函数的名称。 子元素用于指定完整的Java类名， 子元素用于指定Java类中的静态方法的签名，方法签名必须指明方法的返回值类型及各个参数的类型，各个参数之间用逗号分隔。
EL注意事项
EL表达式是JSP 2.0规范中的一门技术 。因此，若想正确解析EL表达式，需使用支持Servlet2.4/JSP2.0技术的WEB服务器。 注意：有些Tomcat服务器如不能使用EL表达式 （1）升级成tomcat6 （2）在JSP中加入
EL表达式保留关键字
所谓保留字的意思是指变量在命名时，应该避开上述的名字，以免程序编译时发生错误，关于EL表达式的内容的总结就这么多。
EL函数库
由于在JSP页面中显示数据时，经常需要对显示的字符串进行处理，SUN公司针对于一些常见处理定义了一套EL函数库供开发者使用。 这些EL函数在JSTL开发包中进行描述，因此在JSP页面中使用SUN公司的EL函数库，需要导入JSTL开发包，并在页面中导入EL函数库，如下所示：
MyEclipse自带的JSTL开发包：
fn.tld就是EL函数库的对应的tld描述文件，如下图所示：
在页面中使用JSTL定义的EL函数：
EL函数使用范例
1
2
3
4
5
6
7
8 EL函数库中的方法使用范例
9
10
11
12 fn:toLowerCase函数使用范例：
13
15
16 fn:toLowerCase("Www.CNBLOGS.COM")的结果是：${fn:toLowerCase("Www.CNBLOGS.COM")}
17
18 fn:toUpperCase函数使用范例：
19
21 fn:toUpperCase("cnblogs.com")的结果是：${fn:toUpperCase("cnblogs.com")}
22
23 fn:trim函数使用范例：
24
26 fn:trim(" cnblogs.com ")的结果是：${fn:trim(" cnblogs.com ")}
27
28 fn:length函数使用范例：
29
35
39 fn:length(list)计算集合list的size的值是：${fn:length(list)}
40
41 fn:length("cnblogs.com")计算字符串的长度是：${fn:length("cnblogs.com")}
42
43 fn:split函数使用范例：
44
48 fn:split("cnblogs.com",".")[0]的结果是：${fn:split("cnblogs.com",".")[0]}
49
50 fn:join函数使用范例：
51
56
60
61 fn:join(StringArray,".")的结果是：${fn:join(StringArray,".")}
62
63
64 fn:join(fn:split("www,iteye,com",","),".")的结果是：${fn:join(fn:split("www,iteye,com",","),".")}
65
66
67 fn:indexOf函数使用范例：
68
74 fn:indexOf("www.iteye.com","eye")的返回值为：${fn:indexOf("www.iteye.com","eye")}
75
76
77 fn:contains函数使用范例：
78
86
93
94 唱歌
96 跳舞
98 蓝球
100 足球
102
103
104 fn:startsWith函数和fn:endsWith函数使用范例：
105
111 fn:startsWith("www.iteye.com","iteye")的返回值为：${fn:startsWith("www.iteye.com","iteye")}
112
113 fn:endsWith("www.iteye.com","com")的返回值为：${fn:endsWith("www.iteye.com","com")}
114
115
116 fn:replace使用范例：
117
122 fn:replace("www iteye com ", " ", ".")的返回值为字符串：${fn:replace("www iteye com", " ", ".")}
123
124
125 fn:substring使用范例：
126
131 fn:substring("www.it315.org", 4, 9) 的返回值为字符串：${fn:substring("www.it315.org", 4, 9)}
132
133 fn:substringAfter函数和fn:substringBefore函数使用范例：
134
139 fn:substringAfter("www.it315.org",".")的返回值为字符串：${fn:substringAfter("www.it315.org",".")}
140
141 fn:substringBefore("www.it315.org",".")的返回值为字符串：${fn:substringBefore("www.it315.org",".")}
142
143
144 jsp页面中使用到的me.gacl.domain.User类的代码如下：
package me.gacl.domain;
public class User {
/**
* 兴趣爱好
*/
private String likes[];
public String[] getLikes() {
return likes;
}
public void setLikes(String[] likes) {
this.likes = likes;
}
}运行结果如下：
国际化开发
java读取properties文件总结
在java项目中，操作properties文件是经常要做的，因为很多的配置信息都会写在properties文件中，这里主要是总结使用getResourceAsStream方法和InputStream流去读取properties文件，使用getResourceAsStream方法去读取properties文件时需要特别注意properties文件路径的写法，测试项目如下：
项目的目录结构
java读取properties文件代码测试
/* 范例名称：java读取properties文件总结
* 源文件名称：PropertiesFileReadTest.java
* 要 点：
* 1. 使用getResourceAsStream方法读取properties文件
* 2. 使用InPutStream流读取properties文件
* 3. 读取properties文件的路径写法问题
*/
package propertiesFile.read.test;
import java.io.BufferedInputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.text.MessageFormat;
import java.util.Properties;
public class PropertiesFileReadTest {
/**
* @param args
*/
public static void main(String[] args) {
try {
readPropFileByGetResourceAsStream();
System.out.println("");
readPropFileByInPutStream();
} catch (Exception e) {
e.printStackTrace();// TODO: handle exception
}
}
/**
* 使用getResourceAsStream方法读取properties文件
*/
static void readPropFileByGetResourceAsStream() {
/**
* 读取src下面config.properties包内的配置文件
* test1.properties位于config.properties包内
*/
InputStream in1 = PropertiesFileReadTest.class.getClassLoader()
.getResourceAsStream("config/properties/test1.properties");
/**
* 读取和PropertiesFileReadTest类位于同一个包里面的配置文件
* test2.properties和PropertiesFileReadTest类在同一个包里面
*/
InputStream in2 = PropertiesFileReadTest.class
.getResourceAsStream("test2.properties");
/**
* 读取src根目录下文件的配置文件
* jdbc.properties位于src目录
*/
InputStream in3 = PropertiesFileReadTest.class.getClassLoader()
.getResourceAsStream("jdbc.properties");
/**
* 读取位于另一个source文件夹里面的配置文件
* config是一个source文件夹，config.properties位于config source文件夹中
*/
InputStream in4 = PropertiesFileReadTest.class.getClassLoader()
.getResourceAsStream("config.properties");
Properties p = new Properties();
System.out.println("----使用getResourceAsStream方法读取properties文件----");
try {
System.out
.println("----------------------------------------------");
p.load(in1);
System.out.println("test1.properties:name=" + p.getProperty("name")
+ ",age=" + p.getProperty("age"));
System.out
.println("----------------------------------------------");
p.load(in2);
System.out.println("test2.properties:name=" + p.getProperty("name")
+ ",age=" + p.getProperty("age"));
System.out
.println("----------------------------------------------");
p.load(in3);
System.out.println("jdbc.properties:");
System.out.println(String.format("jdbc.driver=%s",
p.getProperty("jdbc.driver")));// 这里的%s是java String占位符
System.out.println(String.format("jdbc.url=%s",
p.getProperty("jdbc.url")));
System.out.println(String.format("jdbc.usename=%s",
p.getProperty("jdbc.usename")));
System.out.println(String.format("jdbc.password=%s",
p.getProperty("jdbc.password")));
System.out
.println("----------------------------------------------");
p.load(in4);
System.out.println("config.properties:");
System.out.println(MessageFormat.format("dbuser={0}",
p.getProperty("dbuser")));// {0}是一个java的字符串占位符
System.out.println(MessageFormat.format("dbpassword={0}",
p.getProperty("dbpassword")));
System.out.println(MessageFormat.format("database={0}",
p.getProperty("database")));
System.out
.println("----------------------------------------------");
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} finally {
if (in1 != null) {
try {
in1.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if (in2 != null) {
try {
in2.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if (in3 != null) {
try {
in3.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if (in4 != null) {
try {
in4.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
/**
* 使用InPutStream流读取properties文件
*/
static void readPropFileByInPutStream() {
InputStream in1 = null;
InputStream in2 = null;
InputStream in3 = null;
InputStream in4 = null;
System.out.println("----使用InputStream流读取properties文件----");
try {
/**
* 读取src根目录下文件的配置文件
* jdbc.properties位于src目录
*/
in1 = new BufferedInputStream(new FileInputStream(
"src/jdbc.properties"));
/**
* 读取src下面config.properties包内的配置文件
* test1.properties位于config.properties包内
*/
in2 = new BufferedInputStream(new FileInputStream(
"src/config/properties/test1.properties"));
/**
* 读取和PropertiesFileReadTest类位于同一个包里面的配置文件
* test2.properties和PropertiesFileReadTest类在同一个包里面
*/
in3 = new BufferedInputStream(new FileInputStream(
"src/propertiesFile/read/test/test2.properties"));
/**
* 读取位于另一个source文件夹里面的配置文件
* config是一个source文件夹，config.properties位于config source文件夹中
*/
in4 = new FileInputStream("config/config.properties");
Properties p = new Properties();
System.out
.println("----------------------------------------------");
p.load(in1);
System.out.println("jdbc.properties:");
System.out.println(String.format("jdbc.driver=%s",
p.getProperty("jdbc.driver")));// 这里的%s是java String占位符
System.out.println(String.format("jdbc.url=%s",
p.getProperty("jdbc.url")));
System.out.println(String.format("jdbc.usename=%s",
p.getProperty("jdbc.usename")));
System.out.println(String.format("jdbc.password=%s",
p.getProperty("jdbc.password")));
System.out
.println("----------------------------------------------");
p.load(in2);
System.out.println("test1.properties:name=" + p.getProperty("name")
+ ",age=" + p.getProperty("age"));
System.out
.println("----------------------------------------------");
p.load(in3);
System.out.println("test2.properties:name=" + p.getProperty("name")
+ ",age=" + p.getProperty("age"));
System.out
.println("----------------------------------------------");
p.load(in4);
System.out.println("config.properties:");
System.out.println(MessageFormat.format("dbuser={0}",
p.getProperty("dbuser")));// {0}是一个java的字符串占位符
System.out.println(MessageFormat.format("dbpassword={0}",
p.getProperty("dbpassword")));
System.out.println(MessageFormat.format("database={0}",
p.getProperty("database")));
System.out
.println("----------------------------------------------");
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} finally {
if (in1 != null) {
try {
in1.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if (in2 != null) {
try {
in2.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if (in3 != null) {
try {
in3.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if (in4 != null) {
try {
in4.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}运行结果：
国际化
软件的国际化：软件开发时，要使它能同时应对世界不同地区和国家的访问，并针对不同地区和国家的访问，提供相应的、符合来访者阅读习惯的页面或数据。 国际化(internationalization)又称为 i18n(读法为i 18 n，据说是因为internationalization(国际化)这个单词从i到n之间有18个英文字母，i18n的名字由此而来)
合格的国际化软件
软件实现国际化，需具备以下两个特征： 1、对于程序中固定使用的文本元素，例如菜单栏、导航条等中使用的文本元素、或错误提示信息，状态信息等，需要根据来访者的地区和国家，选择不同语言的文本为之服务。 2、对于程序动态产生的数据，例如(日期，货币等)，软件应能根据当前所在的国家或地区的文化习惯进行显示。
固定文本元素的国际化
对于软件中的菜单栏、导航条、错误提示信息，状态信息等这些固定不变的文本信息，可以把它们写在一个properties文件中，并根据不同的国家编写不同的properties文件。这一组properties文件称之为一个资源包。
创建资源包和资源文件
一个资源包中的每个资源文件都必须拥有共同的基名。除了基名，每个资源文件的名称中还必须有标识其本地信息的附加部分。例如：一个资源包的基名是“myproperties”，则与中文、英文环境相对应的资源文件名则为: "myproperties_zh.properties" "myproperties_en.properties"
每个资源包都应有一个默认资源文件，这个文件不带有标识本地信息的附加部分。若ResourceBundle对象在资源包中找不到与用户匹配的资源文件，它将选择该资源包中与用户最相近的资源文件，如果再找不到，则使用默认资源文件。例如：myproperties.properties
资源文件的书写格式
资源文件的内容通常采用"关键字＝值"的形式，软件根据关键字检索值显示在页面上。一个资源包中的所有资源文件的关键字必须相同，值则为相应国家的文字。 并且资源文件中采用的是properties格式文件，所以文件中的所有字符都必须是ASCII字码，属性(properties)文件是不能保存中文的，对于像中文这样的非ACSII字符，须先进行编码。
例如：
国际化的中文环境的properties文件
国际化的英文环境的properties文件
java提供了一个native2ascII工具用于将中文字符进行编码处理，native2ascII的用法如下所示：
编程实现固定文本的国际化
在JavaAPI中提供了一个ResourceBundle 类用于描述一个资源包，并且 ResourceBundle类提供了相应的方法getBundle，这个方法可以根据来访者的国家地区自动获取与之对应的资源文件予以显示。
ResourceBundle类提供了一个静态方法getBundle，该方法用于装载资源文件，并创建ResourceBundle实例：
Locale currentLocale = Locale.getDefault();
ResourceBundle myResources =ResourceBundle.getBundle(basename, currentLocale);basename为资源包基名(且必须为完整路径)。 如果与该locale对象匹配的资源包子类找不到。一般情况下，则选用默认资源文件予以显示。 加载资源文件后， 程序就可以调用ResourceBundle 实例对象的 getString 方法获取指定的资源信息名称所对应的值。
String value = myResources.getString(“key");范例：根据国家地区自动获取与之对应的资源文件
package me.gacl.i18n;
import java.util.Locale;
import java.util.ResourceBundle;
/**
*@ClassName: I18NTest
* @Description: 编程实现固定文本的国际化
*
*/
public class I18NTest {
public static void main(String[] args) {
//资源包基名(包名+myproperties)
String basename = "me.gacl.i18n.resource.myproperties";
//设置语言环境
Locale cn = Locale.CHINA;//中文
Locale us = Locale.US;//英文
//根据基名和语言环境加载对应的语言资源文件
ResourceBundle myResourcesCN = ResourceBundle.getBundle(basename,cn);//加载myproperties_zh.properties
ResourceBundle myResourcesUS = ResourceBundle.getBundle(basename,us);//加载myproperties_en.properties
//加载资源文件后， 程序就可以调用ResourceBundle实例对象的 getString方法获取指定的资源信息名称所对应的值。
//String value = myResources.getString(“key");
String usernameCN = myResourcesCN.getString("username");
String passwordCN = myResourcesCN.getString("password");
String usernameUS = myResourcesUS.getString("username");
String passwordUS = myResourcesUS.getString("password");
System.out.println(usernameCN+"--"+passwordCN);
System.out.println(usernameUS+"--"+passwordUS);
}
}运行结果：
在WEB应用中实现固定文本的国际化
如下所示：
国际化(i18n)测试
：
：
运行结果：
浏览器语言是中文环境下的显示效果：
浏览器语言是英文环境下的显示效果：
同样一个页面，在不同语言环境的浏览器下显示出了不同的语言文字效果，这样就实现了固定文本的国际化。
IE浏览器切换使用语言：工具→Internet选项
动态数据的国际化
数值，货币，时间，日期等数据由于可能在程序运行时动态产生，所以无法像文字一样简单地将它们从应用程序中分离出来，而是需要特殊处理。Java 中提供了解决这些问题的 API 类(位于 java.util 包和 java.text 包中)
Locale 类
Locale 实例对象代表一个特定的地理，政治、文化区域。 一个 Locale 对象本身不会验证它代表的语言和国家地区信息是否正确，只是向本地敏感的类提供国家地区信息，与国际化相关的格式化和解析任务由本地敏感的类去完成。(若JDK中的某个类在运行时需要根据 Locale 对象来调整其功能，这个类就称为本地敏感类)
DateFormat类(日期格式化)
DateFormat 类可以将一个日期/时间对象格式化为表示某个国家地区的日期/时间字符串。 DateFormat 类除了可按国家地区格式化输出日期外，它还定义了一些用于描述日期/时间的显示模式的 int 型的常量，包括FULL, LONG, MEDIUM, DEFAULT, SHORT，实例化DateFormat对象时，可以使用这些常量，控制日期/时间的显示长度。
实例化DateFormat类
实例化DateFormat类有九种方式，以下三种为带参形式，下面列出的三种方式也可以分别不带参，或只带显示样式的参数。 getDateInstance(int style, Locale aLocale)：以指定的日期显示模式和本地信息来获得DateFormat实例对象，该实例对象不处理时间值部分。 getTimeInstance(int style, Locale aLocale)：以指定的时间显示模式和本地信息来获得DateFormat实例对象，该实例对象不处理日期值部分。 getDateTimeInstance(int dateStyle, int timeStyle, Locale aLocale)：以单独指定的日期显示模式、时间显示模式和本地信息来获得DateFormat实例对象。
DateFormat 对象的方法
format：将date对象格式化为符合某个本地环境习惯的字符串。 parse：将字符串解析为日期/时间对象 注意：parse和format完全相反，一个是把date时间转化为相应地区和国家的显示样式，一个是把相应地区的时间日期转化成date对象，该方法在使用时，解析的时间或日期要符合指定的国家、地区格式，否则会抛异常。 DateFormat 对象通常不是线程安全的，每个线程都应该创建自己的 DateFormat 实例对象
DateFormat使用范例
package me.gacl.i18n;
import java.text.DateFormat;
import java.text.ParseException;
import java.util.Date;
import java.util.Locale;
/**
* @ClassName: DateFormatTest
* @Description: DateFormat类测试
* DateFormat类可以将一个日期/时间对象格式化为表示某个国家地区的日期/时间字符串
*
*/
public class DateFormatTest {
public static void main(String[] args) throws ParseException {
Date date = new Date(); // 当前这一刻的时间（日期、时间）
// 输出日期部分
DateFormat df = DateFormat.getDateInstance(DateFormat.FULL,Locale.GERMAN);
String result = df.format(date);
System.out.println(result);
// 输出时间部分
df = DateFormat.getTimeInstance(DateFormat.FULL, Locale.CHINA);
result = df.format(date);
System.out.println(result);
// 输出日期和时间
df = DateFormat.getDateTimeInstance(DateFormat.SHORT, DateFormat.LONG,Locale.CHINA);
result = df.format(date);
System.out.println(result);
// 把字符串反向解析成一个date对象
String s = "10-9-26 下午02时49分53秒";
df = DateFormat.getDateTimeInstance(DateFormat.SHORT, DateFormat.LONG,Locale.CHINA);
Date d = df.parse(s);
System.out.println(d);
}
}NumberFormat类(数字格式化)
NumberFormat类可以将一个数值格式化为符合某个国家地区习惯的数值字符串，也可以将符合某个国家地区习惯的数值字符串解析为对应的数值 NumberFormat类的方法： format 方法：将一个数值格式化为符合某个国家地区习惯的数值字符串 parse 方法：将符合某个国家地区习惯的数值字符串解析为对应的数值。 实例化NumberFormat类时，可以使用locale对象作为参数，也可以不使用，下面列出的是使用参数的。
- getNumberInstance(Locale locale)：以参数locale对象所标识的本地信息来获得具有多种用途的NumberFormat实例对象
- getIntegerInstance(Locale locale)：以参数locale对象所标识的本地信息来获得处理整数的NumberFormat实例对象
- getCurrencyInstance(Locale locale)：以参数locale对象所标识的本地信息来获得处理货币的NumberFormat实例对象
- getPercentInstance(Locale locale)：以参数locale对象所标识的本地信息来获得处理百分比数值的NumberFormat实例对象
范例：
package me.gacl.i18n;
import java.text.NumberFormat;
import java.text.ParseException;
import java.util.Locale;
/**
* @ClassName: NumberFormatTest
* @Description: NumberFormat类测试
*
*/
public class NumberFormatTest {
public static void main(String[] args) throws ParseException {
int price = 89;
NumberFormat nf = NumberFormat.getCurrencyInstance(Locale.CHINA);
String result = nf.format(price);
System.out.println(result);
String s = "￥89.00";
nf = NumberFormat.getCurrencyInstance(Locale.CHINA);
Number n = nf.parse(s);
System.out.println(n.doubleValue() + 1);
double num = 0.5;
nf = NumberFormat.getPercentInstance();
System.out.println(nf.format(num));
}
}运行结果：
MessageFormat(文本格式化)
如果一个字符串中包含了多个与国际化相关的数据，可以使用MessageFormat类对这些数据进行批量处理。 例如：At 12:30 pm on jul 3,1998, a hurricance destroyed 99 houses and caused $1000000 of damage 以上字符串中包含了时间、数字、货币等多个与国际化相关的数据，对于这种字符串，可以使用MessageFormat类对其国际化相关的数据进行批量处理。 MessageFormat 类如何进行批量处理呢？ 1.MessageFormat类允许开发人员用占位符替换掉字符串中的敏感数据（即国际化相关的数据）。 2.MessageFormat类在格式化输出包含占位符的文本时，messageFormat类可以接收一个参数数组，以替换文本中的每一个占位符。
模式字符串与占位符
模式字符串：
At {0} on {1},a destroyed {2} houses and caused {3} of damage
字符串中的{0}、{1}、{2}、{3}就是占位符
格式化模式字符串
1、实例化MessageFormat对象，并装载相应的模式字符串。
2、使用format(object obj[])格式化输出模式字符串，参数数组中指定占位符相应的替换对象。
范例：
package me.gacl.i18n;
import java.text.MessageFormat;
import java.util.Date;
import java.util.Locale;
/**
* @ClassName: MessageFormatTest
* @Description: MessageFormat类测试
*
*/
public class MessageFormatTest {
public static void main(String[] args) {
//模式字符串
String pattern = "On {0}, a hurricance destroyed {1} houses and caused {2} of damage.";
//实例化MessageFormat对象，并装载相应的模式字符串
MessageFormat format = new MessageFormat(pattern, Locale.CHINA);
Object arr[] = {new Date(), 99, 100000000};
//格式化模式字符串，参数数组中指定占位符相应的替换对象
String result = format.format(arr);
System.out.println(result);
}
}运行结果：
占位符的三种书写方式
{argumentIndex}: 0-9 之间的数字，表示要格式化对象数据在参数数组中的索引号 {argumentIndex,formatType}: 参数的格式化类型 {argumentIndex,formatType,FormatStyle}: 格式化的样式，它的值必须是与格式化类型相匹配的合法模式、或表示合法模式的字符串。
范例：
package me.gacl.i18n;
import java.text.MessageFormat;
import java.util.Date;
import java.util.Locale;
/**
* @ClassName: MessageFormatTest
* @Description: MessageFormat类测试
*
*/
public class MessageFormatTest {
public static void main(String[] args) {
//模式字符串
String pattern = "At {0, time, short} on {0, date}, a destroyed {1} houses and caused {2, number, currency} of damage.";
//实例化MessageFormat对象，并装载相应的模式字符串
MessageFormat format = new MessageFormat(pattern, Locale.US);
Object arr[] = {new Date(), 99, 100000000};
//格式化模式字符串，参数数组中指定占位符相应的替换对象
String result = format.format(arr);
System.out.println(result);
}
}运行结果：
在WEB应用中使用国际化标签库实现固定文本的国际化
国际化(i18n)测试
--%>
以上就是JavaWeb开发中国际化的总结内容。
