国际化英文单词为：Internationalization，又称I18N，I为因为单词的第一个字母，18为这个单词的长度，而N代表这个单词的最后一个字母。国际化又称本地化（Localization,L10N）。
国际化相关的Java类
Java国际化主要通过如下3个类完成
java.util.ResourceBundle:用于加载一个资源包
java.util.Locale：对应一个特定的国家/区域、语言环境。
java.text.MessageFormat：用于将消息格式化
//这是获取计算机默认的语言环境
Locale locale1 = Locale.getDefault();
//读取国际化资源文件：baseName_国家代码_语言代码.如：MessageResource_zh_CN
ResourceBundle boundle1 = ResourceBundle.getBundle("MessageResource", locale1);
System.out.println(boundle1.getString("用户名"));
//创建一个英文环境的locale对象
Locale locale2 = new Locale("en","US");
//读取国际化资源文件
ResourceBundle boundle2 = ResourceBundle.getBundle("MessageResource", locale2);
//根据key来输出value
System.out.println(boundle2.getString("username"));
JAVA国际化流程
ResourceBundle根据Locale加载资源文件->返回一个ResourceBundle实例->ResourceBundle调用getString方法返回指定key对应的字符串
占位符的问题：
资源文件：msg=你好，{0}!今天是{1}
ResourceBundle bundle = ResourceBundle.getBundle("MessageResource", currentLocale);
//获取key为msg的value
String msg = bundle.getString("msg");
//对占位符进行填充
System.out.println(MessageFormat.format(msg,"Eason", new Date()));
资源文件:
MessageResource_en_US.properties
MessageResource_zh_CN.properties
struts的国际化：
第一种方法：读取普通的资源文件(没有占位符的资源文件)
1、把MessageResource国际化资源文件写好key-value
如: login.username——用户名 login.passowrd——密码
login.username——username login.password——password
2、在你的首页(index.jsp)写上链接
<a href=/blog_article/"ChangeAction/lan/zh/quot;/gt;中文/lt;/a/gt;_br.do>
<a href=/blog_article/"ChangeAction/lan/en/quot;/gt;English/lt;/a/gt;_br.do>
3、在你的struts-config.xml中配置baseName
<message-resources parameter="MessageResource"></message-resources>
4、写一个类继承Action并重写execute()方法
//接收参数
String lan = request.getParameter("lan");
//获取默认的Locale
Locale locale = (Locale) request.getSession().getAttribute(Globals.LOCALE_KEY);
//判断参数的语言代码
if("zh".equals(lan)){
//创建一个新的语言locale
locale = new Locale("zh","CN");
}else if("en".equals(lan)){
locale = new Locale("en","US");
}
//把locale写到Action中
this.setLocale(request, locale);
return mapping.findForward("ok");
5、在struts-config.xml中配置Action
<action path="/ChangeAction"
parameter="lan"
type="com.jxau.action.ChangeAction">
<forward name="ok" path="/login.jsp"></forward>
</action>
6、在选择语言后的页面(login.jsp)中要用到bean标签
<%@ taglib uri="http://struts.apache.org/tags-bean" prefix="bean" %>
<form action="User.do?command=addUser" method="post">
<bean:message key="login.username"/>:<input type="text" name="username"><br>
<bean:message key="login.password"/>:<input type="password" name="password">
<input type="submit" value="<bean:message key="login.submit"/>">
<input type="reset" value="<bean:message key="login.reset"/>">
</form>
7、在浏览器中访问你的index.jsp
如何填充struts的占位符
根据上一个添加user的例子来实现此功能
1、在添加用户的时候提交给UserAction中的addUser()
DynaActionForm daf = (DynaActionForm)form;
String username = daf.getString("username");
String password = daf.getString("password");
//创建ActionMessages
ActionMessages msgs = new ActionMessages();
//根据资源文件的key来创建一个ActionMessage
ActionMessage msg = new ActionMessage("login.username.success", username);
User user = new User();
user.setPassword(password);
user.setUsername(username);
//调用业务逻辑
new UserService().saveUser(user);
//把ActionMessage添加到ActionMessages中
msgs.add("abc", msg);
//把ActionMessages保存到request中
this.saveMessages(request, msgs);
return mapping.findForward("ok");
2、然后 根据返回的ActionForward来跳转到msg.jsp中
<bean:message key="login.username.success" arg0="${userForm.map.username}"/>
arg0就是从资源文件中key=login.username.success取值出来
简单工厂模式又称静态工厂方法模式。从命名上就可以看出这个模式一定很简单。它存
在的目的很简单：定义一个用于创建对象的接口。
先来看看它的组成：
1) 工厂类角色：这是本模式的核心，含有一定的商业逻辑和判断逻辑。在java中它往往由
一个具体类实现。
2) 抽象产品角色：它一般是具体产品继承的父类或者实现的接口。在java中由接口或者抽
象类来实现。
3) 具体产品角色：工厂类所创建的对象就是此角色的实例。在java中由一个具体类实现。
//抽象产品角色
public interface Fruit
{
public void get();
}
//具体产品角色
public class Apple implements Fruit
{
public void get()
{
System.out.println("采摘苹果");
}
}
public class Banana implements Fruit
{
public void get()
{
System.out.println("采摘香蕉");
}
}//工厂类角色
public class FruitFactory
{
public static Fruit getFruit(String type) throws InstantiationException, IllegalAccessException
{//工厂方法.注意返回类型为抽象产品角色
// if(type.equalsIgnoreCase("apple"))
// {
// return Apple.class.newInstance();
// }
// else if(type.equalsIgnoreCase("banana"))
// {
// return Banana.class.newInstance();
// }
try
{
Class fruit=Class.forName(type);//type需要类名的全路径
return (Fruit) fruit.newInstance();
} catch (ClassNotFoundException e)
{
// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println("找不到相应的实例化类");
return null;
}
}public class MainClass
{
/**
* @param args
* @throws IllegalAccessException
* @throws InstantiationException
*/
public static void main(String[] args) throws InstantiationException, IllegalAccessException
{
// TODO Auto-generated method stub
//简单工厂模式
// Fruit apple=FruitFactory.getFruit("apple");
// apple.get();
// Fruit banana=FruitFactory.getFruit("banana");
// banana.get();
Fruit apple=FruitFactory.getFruit("design.pattern.simplefactory.Apple");//注意是全路径
apple.get();
Fruit banana=FruitFactory.getFruit("design.pattern.simplefactory.Banana");
banana.get();
}
}
2.工厂方法模式：
工厂方法模式去掉了简单工厂模式中工厂方法的静态属性，使得它可以被子类继承。这
样在简单工厂模式里集中在工厂方法上的压力可以由工厂方法模式里不同的工厂子类来分
担。
1) 抽象工厂角色： 这是工厂方法模式的核心，它与应用程序无关。是具体工厂角色必须
实现的接口或者必须继承的父类。在java 中它由抽象类或者接口来实现。
2) 具体工厂角色：它含有和具体业务逻辑有关的代码。由应用程序调用以创建对应的具体
产品的对象。
3) 抽象产品角色：它是具体产品继承的父类或者是实现的接口。在 java 中一般有抽象类
或者接口来实现。
4) 具体产品角色：具体工厂角色所创建的对象就是此角色的实例。在 java 中由具体的类
来实现。
//抽象产品角色，具体产品角色与简单工厂模式类似，只是变得复杂了些，这里略。
//抽象工厂角色
public interface FruitFactoryInterface
{
public Fruit getFruit();
}
public class OrangeFactory implements FruitFactoryInterface
{
@Override
public Fruit getFruit()
{
// TODO Auto-generated method stub
return new Orange();
}
}
public class PearFactory implements FruitFactoryInterface
{
@Override
public Fruit getFruit()
{
// TODO Auto-generated method stub
return new Pear();
}
}
//应该和具体产品形成对应关系...
public class MainClass
{
/**
* @param args
* @throws IllegalAccessException
* @throws InstantiationException
*/
public static void main(String[] args) throws InstantiationException, IllegalAccessException
{
// TODO Auto-generated method stub
FruitFactoryInterface ffi_0=new PearFactory();//工厂方法模式
Fruit pear=ffi_0.getFruit();
pear.get();
FruitFactoryInterface ffi_1=new OrangeFactory();
Fruit orange=ffi_1.getFruit();
orange.get();
}
}
缺点
可以看出工厂方法的加入，使得对象的数量成倍增长。当产品种类非常多时，会出现大量的与之对应的工厂对象，这不是我们所希望的。
解决办法为了避免这种情况，可以考虑使用简单工厂模式与工厂方法模式相结合的方式来减少工厂类：即对于产品树上类似的种类（一般是树的叶子中互为兄弟的）使用简单工厂模式来实现。
简单工厂模式与工厂方法模式真正的避免了代码的改动了？
没有。在简单工厂模式中，新产品的加入要
DispachAction是动态的指定Action。也就是说在view层的不同的请求和url参数被ActionServlet所截获，
并在struts-config.xml中根据请求得到参数不同来指定(调用)Action中不同的方法，根据方法的返回值来跳转相应的页面。
这样可以很好的解决Action膨胀的问题。以前我们继承struts中的Action只处理一种请求，也就是说不同的请求会有相应的Action类，这样Action类就会越来越多，就会照成Action膨胀。用DispachAction会根据请求的不同来指定调用哪个方法，这样可以有效的解决Action膨胀的问题。
如何使用DispachAction：
1.写一个UserAction继承DispachAction
写一个addUser方法添加用户
//添加User
public ActionForward addUser(ActionMapping mapping, ActionForm arg1,
HttpServletRequest arg2, HttpServletResponse arg3) throws Exception {
new UserService().saveUser(new User());
return mapping.findForward("ok");
}写一个deleteUser方法删除用户
//删除User
public ActionForward deleteUser(ActionMapping mapping, ActionForm arg1,
HttpServletRequest arg2, HttpServletResponse arg3) throws Exception {
return mapping.findForward("delok");
}
2.在页面上
<form action="User.do?command=addUser" method="post"> username:<input type="text" name="username"><br> password:<input type="password" name="password"> <input type="submit" value="提交"> </form> <a href=/blog_article/"User/id/1/amp;command/deleteUser/quot;/gt;删除id为1的用户/lt;/a/gt;_/pre.do>
3.在struts-config.xml配置
<action-mappings> <action path="/User" parameter="command" type="com.jxau.action.UserAction"> <forward name="ok" path="/add_ok.jsp"></forward> <forward name="delok" path="/del_ok.jsp"></forward> </action> </action-mappings>
总结：用DispatchAction可以动态的控制Action，根据一个模板一个Action的原则来管理一个业务逻辑。有效的防止Action膨胀的问题
作者：nc_wanjing 发表于2013-6-18 10:51:49 原文链接阅读：48 评论：0 查看评论