posts - 41,  comments - 8,  trackbacks - 0
  2008年10月3日
     摘要: * 此框架采用前后台分开,前后台都可以单独部署,前端采用轻量级的扁平化设计(html+javascript+Bootstrap), 会自动针对不同的屏幕尺寸调整页面,使其在各个尺寸的屏幕上表现良好。
* 后端采用Spring boot,它使我们更容易去创建基于Spring的独立和产品级的可以即时运行的应用和服务。直接嵌入Tomcat 或Jetty服务器,不需要部署WAR 文件,可直接运行jar文件。
* 系统权限框架采用Shiro,实现前后台权限校验 * 持久层采用JPA ,并实现类ibatis的查询功能;数据响应该采用json格式。
* 服务采用REST形式,能够方便的与手机app进行对接,集成swagger能够在线查看RESTAPI 文档和在线测试服务接口
* 支持单点登录,可以多系统进行菜单集成,形成一个portal
* 支持高并发和水平扩展,支持Session的统一存储
* 项目采用gradle构建,能够方便的将各项目进行按需组装  阅读全文
posted @ 2016-06-13 10:00 Loy Fu 阅读(3530) | 评论 (0)编辑 收藏
     摘要: java nio的全称是java new I/O,即一个全新的I/O控制系统,它的API的包名为java.nio,是在jdk1.4后引入的。 nio之所以为为新,在于它并没在原来I/O的基础上进行开发,而是提供了全新的类和接口,除了原来的基本功能之外,它还提供了以下新的特征:         ► 多路选择的非封锁式...  阅读全文
posted @ 2008-10-21 17:44 Loy Fu 阅读(644) | 评论 (0)编辑 收藏
 作者:罗代均 ldj_work#126.com,转载请保持完整性
环境说明

       Apache  :apache_2.0.55     1 个

       Tomcat:  apache-tomcat-5.5.17 (zip版) 2个

       mod_jk:: mod_jk-apache-2.0.55.so  1个

第一部分:负载均衡

    负载均衡,就是apache将客户请求均衡的分给tomcat1,tomcat2....去处理

   1.安装apche,tomcat

   http://httpd.apache.org/ 下载Apache 2.0.55

    http://tomcat.apache.org/download-55.cgi 下载tomcat5.5 zip版本(解压即可,绿色版)

   http://apache.justdn.org/tomcat/tomcat-connectors/jk/binaries/win32/jk-1.2.15/  下载mod_jk,注意和  apache版本匹配

   按照jdk,我的路径为:E:\ide\apache\Apache2

   解压两份Tomcat, 路径分别为 E:\ide\tomcat1,E:\ide\tomcat2

下载mod_jk

2.修改Apache配置文件http.conf

   在apache安装目录下conf目录中找到http.conf

   在文件最后加上下面一句话就可以了

  include "E:\ide\apache\Apache2\conf\mod_jk.conf"

2. http.conf 同目录下新建mod_jk.conf文件,内容如下
  
#加载mod_jk Module
LoadModule jk_module modules/mod_jk-apache-2.0.55.so
#指定 workers.properties文件路径
JkWorkersFile conf/workers.properties
#指定那些请求交给tomcat处理,"controller"为在workers.propertise里指定的负载分配控制器
JkMount /*.jsp controller
3.在http.conf同目录下新建 workers.properties文件,内容如下
 
worker.list = controller,tomcat1,tomcat2  #server 列表
#========tomcat1========
worker.tomcat1.port=8009         #ajp13 端口号,在tomcat下server.xml配置,默认8009
worker.tomcat1.host=localhost  #tomcat的主机地址,如不为本机,请填写ip地址
worker.tomcat1.type=ajp13
worker.tomcat1.lbfactor = 1   #server的加权比重,值越高,分得的请求越多
#========tomcat2========
worker.tomcat2.port=9009       #ajp13 端口号,在tomcat下server.xml配置,默认8009
worker.tomcat2.host=localhost  #tomcat的主机地址,如不为本机,请填写ip地址
worker.tomcat2.type=ajp13
worker.tomcat2.lbfactor = 1   #server的加权比重,值越高,分得的请求越多

#========controller,负载均衡控制器========
worker.controller.type=lb
worker.controller.balanced_workers=tomcat1,tomcat2   #指定分担请求的tomcat
worker.controller.sticky_session=1
4.修改tomcat配置文件server.xml
如果你在不同电脑上安装tomcat,tomcat的安装数量为一个,可以不必修改tomcat配置文件
我这里是在同一台电脑上安装两个tomcat,所以需要更改其中一个的设置
打开tomcat2/conf/server.xml文件
5.编写一个测试jsp
建立一个目录test.里面新建一个test.jsp,内容为
<%
   System.out.println("===========================");
%>
把test放到tomcat1,tomcat2的webapps下
6.启动apache,tomcat1,tomcat2,进行测试
通过 http://localhost/test/test.jsp 访问,查看tomcat1的窗口,可以看到打印了一行"=========="
再刷新一次,tomcat2也打印了一条,再刷新,可以看到请求会被tomcat1,tomcat2轮流处理,实现了负载均衡
第二部分,配置集群
   只配置负载均衡还不行,还要session复制,也就是说其中任何一个tomcat的添加的session,是要同步复制到其它tomcat, 集群内的tomcat都有相同的session
1. 修改tomcat1, tomcat2的server.xml,将集群部分配置的在注释符删掉,并将tomcat2的4001端口改为4002,以避免与tomcat冲突,当然,如果是两台电脑,是不用改端口的,去掉注释符即可
  
2,修改测试项目test
修改test.jsp,内容如下
  <%@ page contentType="text/html; charset=GBK" %>
<%@ page import="java.util.*" %>
<html><head><title>Cluster App Test</title></head>
<body>
Server Info:
<%
out.println(request.getLocalAddr() + " : " + request.getLocalPort()+"<br>");%>
<%
  out.println("<br> ID " + session.getId()+"<br>");
  // 如果有新的 Session 属性设置
  String dataName = request.getParameter("dataName");
  if (dataName != null && dataName.length() > 0) {
     String dataValue = request.getParameter("dataValue");
     session.setAttribute(dataName, dataValue);
  }
  out.print("<b>Session 列表</b>");
  Enumeration e = session.getAttributeNames();
  while (e.hasMoreElements()) {
     String name = (String)e.nextElement();
     String value = session.getAttribute(name).toString();
     out.println( name + " = " + value+"<br>");
         System.out.println( name + " = " + value);
   }
%>
  <form action="index.jsp" method="POST">
    名称:<input type=text size=20 name="dataName">
     <br>
    值:<input type=text size=20 name="dataValue">
     <br>
    <input type=submit>
   </form>
</body>
</html>
然后在test 新建WEB-INF目录,WEB-INF下新建web.xml,内容如下
<web-app xmlns="http://java.sun.com/xml/ns/j2ee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd" version="2.4">
       <display-name>TomcatDemo</display-name>
       <distributable/>
</web-app>
注意:在你的应用的web.xml加入  <distributable/> 即可
ok,讲test复制到tomcat1,tomcat2的webapps下,重启apache,tomcat1,tomcat2,
新建一个 名称为 xiaoluo  ,值为 cdut 的session,提交查询,新开一个ie窗口,再提交查询,如图,可以看到,两个tomcat 是负载均衡,并且session同步的
posted @ 2008-10-20 08:49 Loy Fu 阅读(353) | 评论 (0)编辑 收藏

在实际的网页开发中,大部分时间都要涉及到Form表单的处理。在Ext框架中也提供了很多这方面的控件,而且还有一个专门的FormPanel布 局,该布局默认为放在面板上面的所有控件都是换行放置,而在实际应用中为了美观,有些需要横排,特别是Radio控件,这个时候就需要我们重新定制这些控 件的布局了,该例子中使用CSS来实现这些功能,先贴出一张效果图。



<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
<title>Ext中FormPanel面板及Form控件横排测试(CSS)</title>
<link rel="stylesheet" type="text/css" media="all" href="../ext/resources/css/ext-all.css" />
<style type="text/css" media="all">
.allow-float {clear:none!important;} /* 允许该元素浮动 */
.stop-float {clear:both!important;} /* 阻止该元素浮动 */
.sex-male {float:left;}
.sex-female {float:left;padding:0 0 0 20px;}
.age-field {float:left;padding:0 0 0 58px;*padding:0 0 0 50px!important;*padding:0 0 0 50px;}
</style>
</head>
<body>
<script type="text/javascript" src="../ext/adapter/ext/ext-base.js"></script>
<script type="text/javascript" src="../ext/ext-all.js"></script>
<script type="text/javascript" src="../ext/build/locale/ext-lang-zh_CN.js"></script>
<script type="text/javascript">Ext.BLANK_IMAGE_URL = '../ext/resources/images/default/s.gif';</script>
<script type="text/javascript">
Ext.onReady(function() {
//创建Form面板
var fp = new Ext.form.FormPanel({
buttonAlign:'center',
labelAlign:'right',
labelWidth:40,
frame:true,
bodyStyle:'padding:8px 0 0 0;',
items:[{
xtype:'textfield',
fieldLabel:'姓名',
name:'n_username',
id:'i_username',
width:320
},{
xtype:'radio',
fieldLabel:'性别',
boxLabel:'男',
name:'sex',
id:'male',
itemCls:'sex-male', //向左边浮动,处理控件横排
clearCls:'allow-float', //允许两边浮动,在实际生成的HTML结构中有专门的DIV阻断浮动
checked:true
},{
xtype:'radio',
boxLabel:'女',
name:'sex',
id:'female',
itemCls:'sex-female', //向左浮动,处理控件横排
clearCls:'allow-float', //允许两边浮动
hideLabel:true //不显示前面"性别"的标签
},{
xtype:'textfield',
fieldLabel:'年龄',
name:'n_age',
id:'i_age',
itemCls:'age-field', //向左浮动,处理控件横排
width:133
},{
xtype:'textfield',
fieldLabel:'住址',
name:'n_address',
id:'i_address',
itemCls:'stop-float', //不允许浮动,结束控件横排
width:320
}],
buttons:[{
text:'确定',
handler:onOK //实际应用一般是处理fp.getForm.submit()事件
}, {
text:'重置',
handler:function(){ fp.getForm().reset(); }
}],
keys:[{ //处理键盘回车事件
key:Ext.EventObject.ENTER,
fn:onOK,
scope:this
}]
});

//确定按钮事件,这里只是简单获取各控件值,实际应用一般和后台脚本结合
function onOK() {
var strMsg;
strMsg = ‘姓名:’ + fp.getComponent(’i_username’).getValue() + ‘,性别:’;
if (fp.getComponent(’male’).checked) strMsg += ‘男’;
if (fp.getComponent(’female’).checked) strMsg += ‘女’;
strMsg += ‘,年龄:’ + fp.getComponent(’i_age’).getValue();
strMsg += ‘,住址:’ + fp.getComponent(’i_address’).getValue();
alert(strMsg);
}

//创建主窗口
new Ext.Window({
title:’Ext中FormPanel面板及Form控件横排测试(CSS)’,
width:400,
closable:false,
collapsible:true,
draggable:false,
resizable:false,
modal:true,
border:false,
items:[fp],
buttons:[]
}).show();
});
</script>
</body>
</html>

posted @ 2008-10-15 13:03 Loy Fu 阅读(583) | 评论 (0)编辑 收藏
Java下的框架编程之cglib的应用
 

Proxy可以看作是微型的AOP,明白提供了在继承和委托之外的第三个代码封装途径,只要有足够的想象力,可以做得非常好玩,Spring的源码里用Proxy就用得很随便,看得我非常眼红。可惜Proxy必须基于接口。因此Spring的做法,基于接口的用proxy,否则就用cglib。AOP么,一般小事非compoent一级的就不麻烦AspectJ出手了。

cglib的Enhancer说起来神奇,用起来一页纸不到就讲完了。

它的原理就是用Enhancer生成一个原有类的子类,并且设置好callback到proxy, 则原有类的每个方法调用都会转为调用实现了MethodInterceptor接口的proxy的intercept() 函数:

                        

public Object intercept(Object o,Method method,Object[] args,MethodProxy proxy)

在intercept()函数里,你可以在执行Object result=proxy.invokeSuper(o,args);来执行原有函数,在执行前后加入自己的东西,改变它的参数值,也可以瞒天过海,完全干别的。说白了,就是AOP中的around advice。

AOP没有出现以前,该领域经典的设计模式是Decorator,像Java IO Stream的设计就是如此。不过,如果为每个DAO, 每个方法的写Decorator函数会写死人的,所以用上cglib的好处是一次过拦截所有方法。 

另外,cglib除了Enhancer之外,还有BulkBean和Transform,都是Hibernate持久化的基础,但文档贫乏,一时还没去看怎么用。

1.AOP里讲了一百遍啊一百遍的log aspect在cglib是这样做的:

                        

public class LogDAOProxy implements MethodInterceptor
   {
       
private Logger log=Logger.getLogger(LogDAOProxy.class);
       
private Enhancer enhancer=new Enhancer();
        
//返回DAO的子类
       public Object getDAO(Class clz)
       {
           enhancer.setSuperclass(clz);
           enhancer.setCallback(
this);
           
return enhancer.create();
       }
       
//默认的拦截方法
      public Object intercept(Object o,Method method,Object[] args,

MethodProxy proxy) throws Throwable
      {
           log.info(
"调用日志方法"+method.getName());
           Object result
=proxy.invokeSuper(o,args);
           
return result;
      }
   }


应用的代码:

                        

LogDAOProxy proxy = new LogDAOProxy();
  GoodsDAO  dao 
= (GoodsDAO)proxy.getDAO(GoodsDAO.class);
  dao.insert(goods);


2.而在Spring的管理下应该略加修改的高级Decorator

上面的例子用return enhancer.create();创建子类实例,但在Spring管理下,一些Bean的实例必须由Spring来创建和管理,而不由enhancer来创建的。所以我对上述用法略加修改,使它真正当一个Proxy的角色,请对比黑体字的部分。

                        

public class LogDAOProxy implements MethodInterceptor
  {
       
private Logger log=Logger.getLogger(LogDAOProxy.class);
       
private Object dao=null;
       
private Enhancer enhancer=new Enhancer();
        
//返回DAO的子类
       public Object getDAO(Class clz,Object dao)
       {
           
this.dao = dao;
           enhancer.setSuperclass(clz);
           enhancer.setCallback(
this);
           
return enhancer.create();
       }      
       
//默认的拦截方法
      public Object intercept(Object o,Method method,Object[] args,

MethodProxy proxy) throws Throwable
      {
           log.info(
"调用日志方法"+method.getName());
           Object result
=proxy.invoke(dao, args);
           
return result;
      }
}


可见,原来模式里在getDao()时由enhancer创建dao,而 调用intercept时则将enhancer创建的dao以Object o参数传回。
而新模式里,dao在getDao()时从外面传入,enhancer.create()返回的是一个proxy. 而调用intercept时,实际会用之前传入的dao进行操作,而忽略Object o参数传入的proxy。

有点遗憾, intercept函数里MethodProxy的Signature是固定的,即客户如果调用foo(String),你不可以用proxy.invoke偷换成foo(String,String);

posted @ 2008-10-08 10:38 Loy Fu 阅读(252) | 评论 (0)编辑 收藏

前台:

Store:

var resource = new Ext.data.Store({
      fields: ['imgpath','typeImage','title', 'type'],
      url: 'teaching/resource/resourceAction.evi?method=getResourceList',
      reader: new Ext.data.XmlReader(
        {
          record: "Item",
          totalRecords: "TotalCount"
        },
      [{name:'title',mapping: 'title'}, {name:'type',mapping: 'type'},{name:'imgpath',mapping: 'imgpath'},{name:'typeImage',mapping: 'typeImage'} ]
    )
});

resource.addListener('load', function(st, rds, opts) {
        // st 是当前的store, rds是读到的Record[], opts是store的配置
   for( var c=0; c<rds.length; c++ ) {
       rds[c].set('typeImage', "<img src='./images/33.gif' width='12' height='12' />");
       //待定类别,先定死类别图片
      }
});

resource.load({params:{start:0,limit:10}});

var resourceType = new Ext.data.Store({
url:'teaching/resourceType/resourceTypeAction.evi?method=getResourceTypeList',
      reader: new Ext.data.XmlReader({
      record: "Item"
     }, [
      {name: 'resourceTypeId', mapping: 'resourceTypeId'},
       {name: 'resourceType', mapping: 'resourceType'}
      ])
   });
resourceType.load();
var languageType = new Ext.data.Store({
url:'teaching/languageType/languageTypeAction.evi?method=getLanguageTypeList',
      reader: new Ext.data.XmlReader({
      record: "Item"
     }, [
       {name: 'languageTypeId', mapping: 'languageTypeId'},
       {name: 'languageType', mapping: 'languageType'}
      ])
   });
languageType.load();

列表:

resourcePanel = new Ext.grid.GridPanel({
id: 'resources',
frame: true,
header: false,
width: 288,
autoWidth: true,
autoHeight: true,
loadMask:{msg:'正在加载数据,请稍侯……'},
iconCls:'icon-grid',
viewConfig: { forceFit: true },
   columns:[
  {header: " ",dataIndex: 'typeImage' , width:20},
  {header: "资源标题", width: 190, sortable: true, dataIndex: 'title'},
  {header: "类别", width: 80, sortable: true, dataIndex: 'type'}
   ],
  store: resource,
  selModel: new Ext.grid.RowSelectionModel({singleSelect:false}),
     bbar: new Ext.PagingToolbar({
  pageSize: 10,
  store: resource,
  displayInfo: false,
  //displayMsg: '显示第 {0} 条到 {1} 条记录,一共 {2} 条',
  emptyMsg: "没有记录" 
      }),
  listeners: {
  rowclick:function(e) {
   try {
    window.parent.parent.Ext.ux.MyTips.msg("提示", "双击该行可预览该资源");
    } catch(e) {}
    },
  rowdblclick:function(g, rIdx, e) {
   var rd = g.getStore().getAt(rIdx);
   var html = "<img src='./images/" + rd.get('imgpath') + "' />";
  window.parent.showWin({
      layout: 'fit',
      maximizable: true,
      title: rd.get('title'),
      width: 400,
      height: 400,
      //modal: true,
      //closeAction: 'hide',
      plain: true,
      items: [ {html: html} ]
    });
  }
}
});

FormPanel:

var rform = new Ext.form.FormPanel({
              id:'rform',
           header: false,
           frame: true,
           hideBorders: false,
           items: [
            new Ext.form.TextField({
             fieldLabel: '关键字',
             name:'keyword'
            }),
            new Ext.form.ComboBox({
             fieldLabel: '资源类别',
             mode: 'local',
             triggerAction: 'all',
             store: resourceType,
             typeAhead: true,
             hiddenName:'resourceTypeId',
             displayField: 'resourceType',
             valueField: 'resourceTypeId',
             readOnly: true,
             selectOnFocus: true
            }),
            new Ext.form.ComboBox({
             fieldLabel: '语言',
             mode: 'local',
             triggerAction: 'all',
             typeAhead: true,
             hiddenName:'languageTypeId',
             displayField:'languageType',
             valueField:'languageTypeId',
             readOnly: true,
             selectOnFocus: true,
             store:languageType
            }),
            new Ext.Panel({
             layout: 'table',
             buttonAlign: 'center',
             layoutConfig: { colspan: 3 },
             buttons:[{text: '搜  寻',
              handler: function() {
                             var keyword = Ext.get('keyword').dom.value;
                             var resourceTypeId = Ext.get('resourceTypeId').dom.value;
                             var languageTypeId = Ext.get('languageTypeId').dom.value;
                      resource.reload({params:{start:0,limit:3,keyword:keyword,resourceTypeId:resourceTypeId,languageTypeId:languageTypeId}});
   //这里不用再写ajax,Ext已经封装了ajax,只要把参数传进去就行了  
              }},
              {
                text: '重  置',
                handler: function() {
                   Ext.getCmp('rform').form.reset();
               }
               }
              ]
            })
           ]
          })

后台:

public ActionForward getResourceList(ActionMapping mapping,
   ActionForm form, HttpServletRequest request,
   HttpServletResponse response) throws IOException {

  Document document = DocumentHelper.createDocument();
  String start = request.getParameter("start");
  String limit = request.getParameter("limit");
  String keyword = request.getParameter("keyword");
  String resourceTypeId = request.getParameter("resourceTypeId");
  String languageTypeId = request.getParameter("languageTypeId");

  List<HqlCondition> hqlFilter = new LinkedList<HqlCondition>();
  if(keyword != null && keyword.length()>0){
   hqlFilter.add( new HqlCondition("and", "rs.title", "like", "%" + keyword + "%", HqlCondition.String) );
   hqlFilter.add( new HqlCondition("or", "rs.remarks", "like", "%" + keyword + "%", HqlCondition.String) );
  }
  if(resourceTypeId != null && resourceTypeId.length()>0){
   hqlFilter.add( new HqlCondition("and", "rs.resourceType.resourceTypeId", "=", new Long(resourceTypeId), HqlCondition.Long) );
  }
  if(languageTypeId != null && languageTypeId.length()>0){
   hqlFilter.add( new HqlCondition("and", "rs.languageType.languageTypeId", "=", new Integer(languageTypeId), HqlCondition.Integer) );
  }
  int pageno =1;
  int pagesize = 10;
  if(limit != null && limit.length()>0){
      pagesize = Integer.parseInt(limit);
  }

  if(!start.equalsIgnoreCase("0") && start != null && start.length()>0){
     int bpos = Integer.parseInt(start);
     pageno = (bpos + pagesize)/pagesize;
  }
  int total = this.rse.getResourceTotalCount(hqlFilter);
  Collection<BaseVO> coll = this.rse.getResourceList(hqlFilter,pageno,pagesize);
  Iterator<BaseVO> it = coll.iterator();
  while(it != null && it.hasNext()){
   BaseVO bv = it.next();
   ResourceType rt = this.rts.getResourceType(((ResourceType)bv.get("resourceType")).getResourceTypeId());
   bv.set("type", rt.getResourceType());
  }
  document.addElement("type");
  new OutputVOXml().writeXML(total,new LinkedList<BaseVO>(coll), response);
  return null;
}

查看更多精彩图片
posted @ 2008-10-04 22:43 Loy Fu 阅读(1100) | 评论 (0)编辑 收藏
 Apache提供的一个插件包,可以把Action中的数据以JSON做个封装然后返回。

它会将整个action中的变量转化为JSON数据(根对象在JSON中数据添加一个”root”标识)。如果要使用它,Action必须遵循以下几点:

1.       返回的页面类型中”content-type”必须是”application/json”.(这个已经Internet Community采用).

2.       JSON内容必须是符合格式要求的.

3.       Actionfield必须有publicset方法.(是不是没有set方法就不会将field添加到JSON数据中,有待验证).

4.       它支持的类型有: 基本类型(int,long...String), Date, List, Map, Primitive Arrays, 其它class, 对象数组.

5.       JSON中任何的Object会被封装在listmap中,数据会被封装程Long,如果是含有的数据则会被封装程Double,数组会被封装程List.

下面给出JSON的数据格式:

{

   "doubleValue": 10.10,

   "nestedBean": {

      "name": "Mr Bean"

   },

   "list": ["A", 10, 20.20, {

      "firstName": "El Zorro"

   }],

   "array": [10, 20]

}

说明:

a.       这个插件支持以下几个注释:

注释名

简介

默认值

序列化

反序列化

name

配置JSONname

empty

yes

no

serialize

serialization

true

yes

no

deserialize

deserialization

true

no

yes

format

格式化Date字段

"yyyy-MM-dd'T'HH:mm:ss"

yes

yes

可以通过配置来显示指出要放在JSONfield,其中有个自己的验证规则需要研究.

<!-- Result fragment -->

<result type="json">

 <param name="excludeProperties">

    login.password,

    studentList.*".sin

 </param>

</result>

<!-- Interceptor fragment -->

<interceptor-ref name="json">

 <param name="enableSMD">true</param>

 <param name="excludeProperties">

    login.password,

    studentList.*".sin

 </param>

</interceptor-ref>

b.       根对象

 <result type="json">

 <param name="root">

    person.job

 </param>

</result>

也可以使用拦截器配置操作父对象

<interceptor-ref name="json">

 <param name="root">bean1.bean2</param>

</interceptor-ref>

c.       JSON数据用注释封装

如果wrapWithComments设置为true(默认值为false),则生成的JSON数据会变成这样:

/* {

   "doubleVal": 10.10,

   "nestedBean": {

      "name": "Mr Bean"

   },

   "list": ["A", 10, 20.20, {

      "firstName": "El Zorro"

   }],

   "array": [10, 20]

} */

这样做可以避免js中一些潜在的风险,使用时需要:

Var responseObject = eval("("+data.substring(data.indexOf(""/"*")+2, data.lastIndexOf(""*"/"))+")");

d.       父类

“root”对象中父类的field不会默认存放到JSON数据中,如果不想这样做,需要在配置时指定ignoreHierarchyfalse:

<result type="json">

 <param name="ignoreHierarchy">false</param>

</result>

e.       枚举类型

默认处理枚举类型时,会被处理成JSON数据中name等于枚举中valuevalue等于枚举中name.

public enum AnEnum {

     ValueA,

     ValueB

 }

 JSON: "myEnum":"ValueA"

如果在处理枚举类型时,在xml中配置了enumAsBean,则会被当作一个Bean处理,在JSON数据中会有一个特别的属性”_name”值为name().这个枚举中的所有属性都会被处理.

public enum AnEnum {

     ValueA("A"),

     ValueB("B");

     private String val;

     public AnEnum(val) {

        this.val = val;

     }

     public getVal() {

        return val;

     }

   }

 JSON: myEnum: { "_name": "ValueA", "val": "A" }

Xml中配置:

<result type="json">

 <param name="enumAsBean">true</param>

</result>

f.        例子

a)         Action

import java.util.HashMap;

import java.util.Map;

import com.opensymphony.xwork2.Action;

public class JSONExample {

    private String field1 = "str";

    private int[] ints = {10, 20};

    private Map map = new HashMap();

    private String customName = "custom";

    //'transient' fields are not serialized

    private transient String field2;

    //fields without getter method are not serialized

    private String field3;

    public String execute() {

        map.put("John", "Galt");

        return Action.SUCCESS;

    }

    public String getField1() {

        return field1;

    }

    public void setField1(String field1) {

        this.field1 = field1;

    }

    public int[] getInts() {

        return ints;

    }

    public void setInts(int[] ints) {

        this.ints = ints;

    }

    public Map getMap() {

        return map;

    }

    public void setMap(Map map) {

        this.map = map;

    }

    @JSON(name="newName")

    public String getCustomName() {

        return this.customName;

    }

}

b)        Xml配置

 <?xml version="1.0" encoding="UTF-8" ?>

<!DOCTYPE struts PUBLIC

    "-//Apache Software Foundation//DTD Struts Configuration 2.0//EN"

    "http://struts.apache.org/dtds/struts-2.0.dtd">

<struts>

 <package name="example" extends="json-default">

     <action name="JSONExample" class="example.JSONExample">

        <result type="json"/>

     </action>

 </package>

</struts>

这里有两个地方需要注意:

1)      需要继承json-default

2)      <result>签的定义

c)         JSON数据

 { 

   "field1" : "str",

   "ints": [10, 20],

   "map": {

       "John":"Galt"

   },

   "newName": "custom"

}

d)        JSON RPC

JSON插件可以在js中调用action方法,返回执行结果。这个已经在dojo中有了实现,可以用Simple Method Definition调用远程服务。来一起看看下面的例子:

首先写一个Action

package smd;

import com.googlecode.jsonplugin.annotations.SMDMethod;

import com.opensymphony.xwork2.Action;

public class SMDAction {

    public String smd() {

        return Action.SUCCESS;

    }

    @SMDMethod

    public Bean doSomething(Bean bean, int quantity) {

        bean.setPrice(quantity * 10);

        return bean;

    }

}

e)         方法必须用SMDMethod加上注解,这样才能被远程调用,为了安全因素。这个方法会产生一个bean对象,实现修改价格的功能。Action被添加上SMD注解会生成一个SMD,同时参数也会被加上SMDMethodParameter注解。像你所看到的,Action中定义了一个空方法:smd。这个方法是作为Simple Method Definition (定义class中提供的服务),在struts.xml配置<result>时使用type属性值为”json”

下面是bean的定义:

package smd;

public class Bean {

    private String type;

    private int price;

    public String getType() {

        return type;

    }

    public void setType(String type) {

        this.type = type;

    }

    public int getPrice() {

        return price;

    }

    public void setPrice(int price) {

        this.price = price;

    }

}

Xml文件:

<package name="RPC" namespace="/nodecorate" extends="json-default">

    <action name="SMDAction" class="smd.SMDAction" method="smd">

        <interceptor-ref name="json">

            <param name="enableSMD">true</param>

        </interceptor-ref>

        <result type="json">

             <param name="enableSMD">true</param>

        </result>

    </action>

</package>

这里需要注意一点:” enableSMD”这个必须在interceptorresult都要配置.

Js代码:

<s:url id="smdUrl" namespace="/nodecorate" action="SMDAction" />

<script type="text/javascript">

    //load dojo RPC

    dojo.require("dojo.rpc.*");

    //create service object(proxy) using SMD (generated by the json result)

    var service = new dojo.rpc.JsonService("${smdUrl}");

    //function called when remote method returns

    var callback = function(bean) {

        alert("Price for " + bean.name + " is " + bean.price);

    };

    //parameter

    var bean = {name: "Mocca"};

    //execute remote method

    var defered = service.doSomething(bean, 5);

    //attach callback to defered object

    defered.addCallback(callback);

</script>

JsonService会发出一个请求到action加载SMD,同时远程方法会返回一个JSON对象,这个过程是Dojoaction中的方法创建了一个Proxy。因为这是异步调用过程,当远程方法执行的时候,它会返回一个对象到callback方法中。

f)         代理的对象

当使用的注解不是继承自Java,可能你使用代理会出现一些问题。比如:当你使用aop拦截你的action的时候。在这种情况下,这个插件不会自动发现注解的方法。为了避免这种情况发生,你需要在xml中配置ignoreInterfacesfalse,这样插件会自己查找注解的所有接口和父类。

注意:这个参数只有在Action执行的过程是通过注解来运行的时候才应该设为false

<action name="contact" class="package.ContactAction" method="smd">

   <interceptor-ref name="json">

      <param name="enableSMD">true</param>

      <param name="ignoreInterfaces">false</param>

   </interceptor-ref>

   <result type="json">

      <param name="enableSMD">true</param>

      <param name="ignoreInterfaces">false</param>

   </result>

   <interceptor-ref name="default"/>

</action>

posted @ 2008-10-04 14:45 Loy Fu 阅读(7530) | 评论 (2)编辑 收藏
struts2json plugin的位置在:http://code.google.com/p/jsonplugin/
下载json plugin的jar包,放到/WEB-INF/lib/目录下就可以了

Spring + Struts + JPA的项目结构如其他例子中的一致
首先是web.xml
xml 代码
 
  1. <?xml version="1.0" encoding="UTF-8"?>  
  2. <web-app id="WebApp_ID" version="2.4"  
  3.     xmlns="http://java.sun.com/xml/ns/j2ee"  
  4.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
  5.     xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd">  
  6.     <display-name>quickstart</display-name>  
  7.     <filter>  
  8.         <filter-name>struts2</filter-name>  
  9.         <filter-class>  
  10.             org.apache.struts2.dispatcher.FilterDispatcher  
  11.         </filter-class>  
  12.     </filter>  
  13.     <filter>  
  14.         <filter-name>jpaFilter</filter-name>  
  15.         <filter-class>  
  16.             org.springframework.orm.jpa.support.OpenEntityManagerInViewFilter  
  17.         </filter-class>  
  18.         <init-param>  
  19.             <param-name>entityManagerFactory</param-name>  
  20.             <param-value>entityManagerFactory</param-value>  
  21.         </init-param>  
  22.     </filter>  
  23.     <filter-mapping>  
  24.         <filter-name>jpaFilter</filter-name>  
  25.         <url-pattern>*.action</url-pattern>  
  26.     </filter-mapping>  
  27.     <filter-mapping>  
  28.         <filter-name>struts2</filter-name>  
  29.         <url-pattern>/*</url-pattern>  
  30.     </filter-mapping>  
  31.     <welcome-file-list>  
  32.         <welcome-file>index.jsp</welcome-file>  
  33.     </welcome-file-list>  
  34.     <listener>  
  35.         <listener-class>  
  36.             org.springframework.web.context.ContextLoaderListener  
  37.         </listener-class>  
  38.     </listener>  
  39. </web-app>  

加入jpaFilter,是为了不让hibernate的session过早关闭,因为有的action会通过ajax动态调用。
下面是struts.xml,注意struts.xml需要放在源代码目录下面:

xml 代码
 
  1. <?xml version="1.0" encoding="UTF-8" ?>  
  2. <!DOCTYPE struts PUBLIC  
  3.     "-//Apache Software Foundation//DTD Struts Configuration 2.0//EN"  
  4.     "http://struts.apache.org/dtds/struts-2.0.dtd">  
  5. <struts>  
  6.     <constant name="struts.objectFactory" value="spring" />  
  7.     <constant name="struts.devMode" value="true" />  
  8.     <constant name="struts.i18n.encoding" value="UTF-8"/>  
  9.     <package name="person" extends="json-default">  
  10.         <action name="list" method="execute" class="personaction">  
  11.             <result type="json"/>  
  12.         </action>         
  13.     </package>  
  14. </struts>  

这里注意,
struts.objectFactory告诉struts所有的action都到spring的上下文里面去找,另外还需要注意,我们自己的包要继承自json-default,这样才可以在result的type属性中使用json
下面是spring的配置文件applicationContext.xml:
xml 代码
 
  1. <?xml version="1.0" encoding="UTF-8"?>  
  2. <beans xmlns="http://www.springframework.org/schema/beans"  
  3.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
  4.     xmlns:aop="http://www.springframework.org/schema/aop"  
  5.     xmlns:tx="http://www.springframework.org/schema/tx"  
  6.     xsi:schemaLocation="  
  7.     http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.0.xsd  
  8.     http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.0.xsd  
  9.     http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.0.xsd">  
  10.     <bean  
  11.         class="org.springframework.orm.jpa.support.PersistenceAnnotationBeanPostProcessor" />  
  12.     <bean id="entityManagerFactory"  
  13.         class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean">  
  14.         <property name="dataSource" ref="dataSource" />  
  15.         <property name="jpaVendorAdapter">  
  16.             <bean  
  17.                 class="org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter">  
  18.                 <property name="database" value="MYSQL" />  
  19.                 <property name="showSql" value="true" />  
  20.             </bean>  
  21.         </property>  
  22.     </bean>  
  23.     <bean id="dataSource"  
  24.         class="org.springframework.jdbc.datasource.DriverManagerDataSource">  
  25.         <property name="driverClassName" value="com.mysql.jdbc.Driver" />  
  26.         <property name="url" value="jdbc:mysql://localhost/extjs" />  
  27.         <property name="username" value="root" />  
  28.         <property name="password" value="" />  
  29.     </bean>  
  30.   
  31.       
  32.     <bean id="transactionManager"  
  33.         class="org.springframework.orm.jpa.JpaTransactionManager">  
  34.         <property name="entityManagerFactory"  
  35.             ref="entityManagerFactory" />  
  36.     </bean>  
  37.     <tx:annotation-driven transaction-manager="transactionManager" />  
  38.     <!--Service 开始 -->  
  39.     <bean id="personService" class="com.myext.service.impl.PersonServiceJpaImpl"/>  
  40.     <bean id="personaction" class="com.myext.action.PersonPageAction">  
  41.         <property name="person" ref="personService"/>  
  42.     </bean>  
  43. </beans>  

这里的bean personaction和strutx.xml中的action class一致就可以了,下面是代码:
action:
java 代码
  1. package com.myext.action;
  2. import java.util.ArrayList;
  3. import java.util.List;
  4. import com.myext.service.PersonService;
  5. public class PersonPageAction {
  6. private int limit=10;
  7. private int start=0;
  8. private PersonService person;
  9. private int total=0;
  10. private List persons = new ArrayList();
  11. private boolean success=true;
  12. public boolean getSuccess(){
  13. return this.success;
  14. }
  15. public void setLimit(int limit) {
  16. this.limit = limit;
  17. }
  18. public void setStart(int start) {
  19. this.start = start;
  20. }
  21. public void setPerson(PersonService person) {
  22. this.person = person;
  23. }
  24. public int getTotal() {
  25. return total;
  26. }
  27. public void setTotal(int total) {
  28. this.total = total;
  29. }
  30. public List getPersons() {
  31. return persons;
  32. }
  33. public void setPersons(List persons) {
  34. this.persons = persons;
  35. }
  36. public String execute(){
  37. this.total = person.getTotal();
  38. this.persons = person.getPage(this.start, this.limit);
  39. return "success";
  40. }
  41. }
service:
java 代码
  1. package com.myext.service.impl;
  2. import java.util.List;
  3. import javax.persistence.EntityManager;
  4. import javax.persistence.PersistenceContext;
  5. import javax.persistence.Query;
  6. import com.myext.model.Person;
  7. import com.myext.service.PersonService;
  8. public class PersonServiceJpaImpl implements PersonService {
  9. private EntityManager em;
  10. private static String poname = Person.class.getName();
  11. @PersistenceContext
  12. public void setEntityManager(EntityManager em){
  13. this.em = em;
  14. }
  15. @SuppressWarnings("unchecked")
  16. @Override
  17. public List getPage( int start, int limit) {
  18. Query q = this.em.createQuery("from " + poname );
  19. q.setFirstResult(start);
  20. q.setMaxResults(limit);
  21. return q.getResultList();
  22. }
  23. @Override
  24. public int getTotal() {
  25. return this.em.createQuery("from " + poname).getResultList().size();
  26. }
  27. }
页面的代码:
xml 代码
  1. xml version="1.0" encoding="UTF-8" ?>
  2. <%@ page language="java" contentType="text/html; charset=UTF-8"
  3. pageEncoding="UTF-8"%>
  4. >
  5. <html xmlns="http://www.w3.org/1999/xhtml">
  6. <head>
  7. <meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
  8. <title>Grid3title>
  9. <link rel="stylesheet" type="text/css" href="extjs/resources/css/ext-all.css" />
  10. <script type="text/javascript" src="extjs/adapter/ext/ext-base.js">script>
  11. <script type="text/javascript" src="extjs/ext-all.js">script>
  12. <script type="text/javascript" src="extjs/ext-lang-zh_CN.js">script>
  13. head>
  14. <body>
  15. <script type="text/javascript" src="grid3.js">script>
  16. <div id="grid3" >
  17. div>
  18. body>
  19. html>
grid3.js代码
js 代码
  1. /**
  2. * @author fox
  3. */
  4. Ext.onReady(function(){
  5. Ext.BLANK_IMAGE_URL = 'extjs/resources/images/default/s.gif';
  6. Ext.QuickTips.init();
  7. var sm = new Ext.grid.CheckboxSelectionModel(); //CheckBox选择列
  8. var cm = new Ext.grid.ColumnModel([
  9. new Ext.grid.RowNumberer(), //行号列
  10. sm,
  11. {header:'编号',dataIndex:'id'},
  12. {header:'性别',dataIndex:'sex',renderer:function(value){
  13. if(value=='male'){
  14. return "";
  15. }else{
  16. return "";
  17. }
  18. }}, //增加性别,自定义renderer,即显示的样式,可以加html代码,来显示图片等。
  19. {header:'名称',dataIndex:'name'},
  20. {header:'描述',dataIndex:'descn'}
  21. ]);
  22. var ds = new Ext.data.Store({
  23. proxy: new Ext.data.HttpProxy({url:'list.action'}),//调用的动作
  24. reader: new Ext.data.JsonReader({
  25. totalProperty: 'total',
  26. root: 'persons',
  27. successProperty :'success'
  28. }, [
  29. {name: 'id',mapping:'id',type:'int'},
  30. {name: 'sex',mapping:'sex',type:'string'},
  31. {name: 'name',mapping:'name',type:'string'},
  32. {name: 'descn',mapping:'descn',type:'string'} //列的映射
  33. ])
  34. });
  35. var grid = new Ext.grid.GridPanel({
  36. el: 'grid3',
  37. ds: ds,
  38. sm: sm,
  39. cm: cm,
  40. width:700,
  41. height:280,
  42. bbar: new Ext.PagingToolbar({
  43. pageSize: 10,
  44. store: ds,
  45. displayInfo: true,
  46. displayMsg: '显示第 {0} 条到 {1} 条记录,一共 {2} 条',
  47. emptyMsg: "没有记录"
  48. }) //页脚显示分页
  49. });
  50. //el:指定html元素用于显示grid
  51. grid.render();//渲染表格
  52. ds.load({params:{start:0, limit:10}}); //加载数据
  53. });
注意,这里的gridpanel一定要设置高度,否则数据是显示不出来的。
最后启动tomcat,在浏览器里输入http://localhost:8080/extjs/grid3.jsp,就可以看到效果
posted @ 2008-10-04 14:35 Loy Fu 阅读(4308) | 评论 (2)编辑 收藏
     摘要: http://prototype.conio.net/dist/ 下载(对Ajax支持的prototype--js函数库): prototype-1.4.0.js 或 prototype-1.4.0.tar.gz   http://code.google.com/p/jsonplugin/downloads/list 下载(Struts2...  阅读全文
posted @ 2008-10-04 14:19 Loy Fu 阅读(1904) | 评论 (0)编辑 收藏
关键字: Struts2 COC
摘要:介绍Struts2中的零配置(Zero Configuration),以及如何用COC来更好地简化Struts2的配置。在第一章,我使用Maven来创建一个起点项目;第二章,以该项目为例,讲解如何使用Struts2的零配置;第三章,论述第二章中的实现方式的缺陷,然后讲解如何使用COC来改进这些缺陷,并进一步简化Struts2的配置。附件是这篇文章用到的示例代码。

一、从零开始

这里,我将建立一个新的示例项目,作为讲解的起点。我使用JDK 6、Maven 2、Eclipse 3.3来建立这个示例,如果读者对Maven2不熟也没关系,这只是个示例。
首先,运行下边的命令:
                mvn archetype:create -DgroupId=demo.struts -DartifactId=demo-struts-coc -DarchetypeArtifactId=maven-archetype-webapp
这会建立如下的目录结构:
 |- POM.xml
 |- src
     |- main
         |- resources
         |- webapp
             |- index.jsp
             |- WEB-INF
                 |- web.xml
然后我们在src/main目录下新建一个名为java的目录,用来放置java代码。在src下建立test目录,并在test目录下建立java目录,用来放置测试代码。另外,我这个示例不想使用JSP,所以我将src/main/webapp目录下的index.jsp改为index.html。
现在,需要配置该项目要用到哪些lib。在POM.xml中加入struts2-core:
xml 代码
 
  1. <dependency>  
  2.     <groupId>org.apache.struts</groupId>  
  3.     <artifactId>struts2-core</artifactId>  
  4.     <version>2.0.9</version>  
  5. </dependency>  

另外,我想在Eclipse里使用jetty来启动项目并进行测试,所以在POM.xml中再加入jetty、jetty-util、servlet-api等的依赖,详情见附件。
我希望使用Eclipse来作为这个项目的IDE,所以,我在命令行状态下,进入这个项目所在的目录,运行:
                mvn eclipse:eclipse
然后使用Eclipse导入这个项目。如果你是第一次用Eclipse导入用Maven生成的项目,那你需要在Eclipse里配置一个名叫M2_REPO的Variable,指向你的Maven 2的repository目录。缺省情况下,它应该位于${user.home}/.m2/repository。
OK!现在我们已经可以在Eclipse中进行工作了。
修改src/main/webapp/WEB-INF/web.xml,加入struts2的FilterDispatcher并设置filter-mapping。在这个示例中我将url-pattern设为"/app/*",也就是说,url的匹配是基于路径来做的。这只是我的个人喜好而已,你也可以将它设成"*"。
既然是在讲struts2的零配置,当然是可以不要任何配置文件的。但是为了更好地进行“配置”,我还是建立了struts.xml文件(在src/main/resources目录下)。我不喜欢url最后都有个action后缀,现在,我在struts.xml中配置struts.action.extension,将这个后缀去掉:
xml 代码
 
  1. <struts>  
  2.     <constant name="struts.action.extension" value="" />  
  3. </struts>  

然后我在src/test/java下建立demo/RunJetty.java文件,main方法如下:
java 代码
 
  1. public static void main(String[] args) throws Exception {  
  2.     Server server = new Server(8080); //也可以改成其它端口  
  3.     File rootDir = new File(RunJetty.class.getResource("/").getPath()).getParentFile().getParentFile();  
  4.     String webAppPath = new File(rootDir, "src/main/webapp").getPath();  
  5.     new WebAppContext(server, webAppPath, "/");  
  6.     server.start();  
  7. }  

现在,在Eclipse里运行或调试这个RunJetty.java,用浏览器打开http://localhost:8080/看看吧。如果不出问题,应该可以访问到webapp目录下的index.html了。有了Jetty,你还在用MyEclipse或其它插件么?

二、零配置

首先要澄清一点,这里说的零配置并不是一点配置都没有,只是说配置很少而已。
Struts2(我只用过Struts 2.0.6和2.0.9,不清楚其它版本是否支持零配置)引入了零配置的新特性,元数据可以通过规则和注解来表达:A "Zero Configuration" Struts application or plugin uses no additional XML or properties files. Metadata is expressed through convention and annotation.
目前,这个新特性还在测试阶段,但经过一段时间的使用,我觉得这个特性已经可用。下面我讲一下如何使用它。
1. Actions的定位
以前需要在xml配置文件中配置Action的name和class,如果使用零配置,所带来的一个问题就是如何定位这些Action。我们需要在web.xml中找到struts2的filter的配置,增加一个名为actionPackages的init-param,它的值是一个以逗号分隔的Java包名列表,比如:demo.actions1,demo.actions2。struts2将会扫描这些包(包括这些包下边的子包),在这些包下,所有实现了Action接口的或者是类名以“Action”结尾的类都会被检查到,并被当做Action。
以前,我们写Action必须要实现Action接口或者继承ActionSupport。但是,上面提到的类名以"Action"结尾的类并不需要这样做,它可以是一个POJO,Struts2支持POJO Action!
下面是actionPackages的配置示例:
xml 代码
 
  1. <filter>  
  2.   <filter-name>struts2</filter-name>  
  3.   <filter-class>org.apache.struts2.dispatcher.FilterDispatcher</filter-class>  
  4.   <init-param>  
  5.     <param-name>actionPackages</param-name>  
  6.     <param-value>demo.actions1,demo.actions2</param-value>  
  7.   </init-param>  
  8. </filter>  

2. 示例
现在我们建立demo.actions1.app.person和demo.actions2.app.group两个包,在demo.actions1.app.person包下建立ListPeopleAction.java,在demo.actions2.app.group下建立ListGroupAction.java。作为示例,这两个类只是包含一个execute方法,返回"success"或"error",其它什么都不做:
java 代码
 
  1. public String execute() {  
  2.     return "success";  
  3. }  

在Filter的配置中,我指定actionPackages为demo.actions1,demo.actions2,当系统启动时,Struts2就会在这两个包下扫描到demo.actions1.app.person.ListPeopleAction和demo.actions2.app.group.ListGroupAction。

3. Action and Package name
Struts2扫描到Action后,从actionPackages指定的包开始,子包名会成为这个Action的namespace,而Action的name则由这个Action的类名决定。将类名首字母小写,如果类名以Action结尾,则去掉"Action"后缀,形成的名字就是这个Action的名字。在如上所述的示例中,actionPackages指定为demo.actions1,demo.actions2,那么你可以这样访问demo.actions1.app.person.ListPeopleAction:
                http://localhost:8080/app/person/listPeople

4. Results
Struts2是通过"Result"和"Results"两个类级别的annotations来指定Results的。
作为示例,我们在webapp目录下建两个html文件:success.html和error.html,随便写点什么内容都可以。现在假设我们访问/app/person/listPeople时,或Action返回success就转到success.html页面,若是error就转到error.html页面,这只需要在ListPeopleAction类上加上一段注解就可以了:
java 代码
 
  1. @Results({  
  2.     @Result(name="success", type=NullResult.class, value = "/success.html", params = {}),  
  3.     @Result(name="error", type=NullResult.class, value = "/error.html", params = {})  
  4. })  
  5. public class ListPeopleAction {  
  6.     public String execute() {  
  7.         return "success";  
  8.     }  
  9. }  

同上,我们给ListGroupAction也加上注解。
现在,我们已经完成了一个零配置的示例。我们并没有在xml文件里配置ListPeopleAction和ListGroupAction,但它们已经可以工作了!
用Eclipse运行RunJetty,然后用浏览器访问http://localhost:8080/app/person/listPeople和http://localhost:8080/app/group/listGroup看看,是不是正是success.html(或error.html)的内容?

5. Namespaces
如上所述,namespace由包名所形成,但我们可以使用"Namespace"注解来自己指定namespace。

6. Parent Package
这个配置用得较少。Struts2提供一个"ParentPackage"注解来标识Action应该是属于哪个package。

三、使用COC

如上所述,Struts2用注解来实现零配置。然而,这不是我喜欢的方式。在我看来,这不过是将配置从XML格式换成了注解方式,并不是真的零配置。而且,这种方式也未必比XML形式的配置更好。另外,对元数据的修改必然会导致项目的重新编译和部署。还有,现在的Struts2版本似乎对Result注解中的params的处理有些问题。
其实,Struts2的actionPackages配置已经使用了COC,那为什么不能为Results也实现COC,从而去除这些每个Action都要写的注解?
在严谨的项目中,package、action的名称和页面的路径、名称一定存在着某种关系。比如,页面的路径可能和package是对应的,页面的名称可能和action的名称是对应的,或是根据某种法则运算得到。我们知道webwork2和struts2有个配置叫global-results。我们为什么不能根据这些对应规则写个Result,将它配到global-results中,从而真正免去result的配置?
事实上,我推荐Struts2的使用者只用Struts2输出XML或JSON,放弃UI,页面这层还是使用标准的HTML、CSS和一些JS组件来展现。许多人反映Struts2慢,确实,Struts2是慢,很慢!慢在哪儿?很大一部分因素是UI这层引起的,特别是使用了过多的Struts2的tag,并使用了ajax theme。但是,如果我们放弃了Struts2的笨拙的UI,Result只输出XML或JSON,UI则使用标准的HTML+CSS,使用JS组件(DOJO、Adobe Spry Framework、YUI-Ext等)来操作Struts2的输出数据,情况将会如何?我们会得到一个高性能、高可配的、UI和应用服务器的职责分割更为明确、合理的、更易于静态化部署的开发组合。
这似乎是阉割了Struts2,但是这样阉割过的Struts2摆脱了性能低下的包袱,更轻、更现代化。
有些扯远了,言归正传,不管是让Struts2输出XML或JSON,还是输出页面,我们都有办法根据项目的规则写一个Result,将它配到global-results中,从而大大减少Result的配置。
假设我们让Struts2只输出JSON,有个jsonplugin可以做这件事。使用JsonResult时,不再需要知道页面的位置、名称等信息,它仅仅是数据输出,那么我们就可以将这个Result配成全局的,大部分Action将不再需要Result的配置。
作为示例,我假设我的例子中输出的两个html页面(success.html和error.html)是JSON,我们看看怎么免去我例子中的两个Action的Result注解。
首先,我们删去ListPeopleAction和ListGroupAction两个Action的注解,并修改struts.xml文件,加入:
xml 代码
 
  1. <package name="demo-default" extends="struts-default">  
  2. <global-results>  
  3. <result name="success">/success.html</result>  
  4. </global-results>  
  5. </package>  

请记住这只是一个示例,为了方便,我没在项目中加入jsonplugin来作真实的演示,我只是假设这个success是json输出,读者可以自行使用jsonplugin来作实验。

现在,离成功不远了,但是项目仍然不能正常运行。我们的Action返回success,但并不会匹配到global-results中配置。为什么呢?因为,我们这里是把global-results配置到"demo-default"这个package下的,而Struts2根据actionPackages找到的Action不会匹配到这个package上。解决办法也很简单,还记得上面讲到的Parent Package吧?给Action加个注解,指定ParentPackage为"demo-default"。但这样可不是我喜欢的,其实有更好的办法,我们在struts.xml中加个constant就好了:
xml 代码
 
  1. <constant name="struts.configuration.classpath.defaultParentPackage" value="demo-default" />  

现在,大功告成!运行RunJetty来测试下吧!你可以访问/app/person/listPeople,可以访问/app/group/listGroup,而所有的配置仅仅是web.xml和struts.xml中的几行,我们的Java代码中也没有加注解。如果再加上几百个Action呢?配置仍然就这几行。
可是,某些Action确实需要配置怎么办?对这些Action,你可以加注解,也可以针对这些Action来写些XML配置。一个项目中,大部分Action的配置是可以遵从一定规则的,可以使用规则来简化配置,只有少部分需要配置,这就是COC。

posted @ 2008-10-04 14:08 Loy Fu 阅读(907) | 评论 (0)编辑 收藏

struts2.0的标签库(简介)
用过struts1.x的人都知道,标签库有html、bean、logic、tiles,
而struts2.0里的标签却没有分类,只用在jsp头文件加上
<%@ taglib prefix="s" uri="/struts-tags" %>
就能使用struts2.0的标签库

下面就介绍下每个标签的用法(有错请指正):

A:

<s:a href=""></s:a>-----超链接,类似于html里的<a></a>
<s:action name=""></s:action>-----执行一个view里面的一个action
<s:actionerror/>-----如果action的errors有值那么显示出来
<s:actionmessage/>-----如果action的message有值那么显示出来
<s:append></s:append>-----添加一个值到list,类似于list.add();
<s:autocompleter></s:autocompleter>-----自动完成<s:combobox>标签的内容,这个是ajax

B:
<s:bean name=""></s:bean>-----类似于struts1.x中的,JavaBean的值

C:
<s:checkbox></s:checkbox>-----复选框
<s:checkboxlist list=""></s:checkboxlist>-----多选框
<s:combobox list=""></s:combobox>-----下拉框
<s:component></s:component>-----图像符号

D:
<s:date/>-----获取日期格式
<s:datetimepicker></s:datetimepicker>-----日期输入框
<s:debug></s:debug>-----显示错误信息
<s:div></s:div>-----表示一个块,类似于html的<div></div>
<s:doubleselect list="" doubleName="" doubleList=""></s:doubleselect>-----双下拉框

E:
<s:if test=""></s:if>
<s:elseif test=""></s:elseif>
<s:else></s:else>-----这3个标签一起使用,表示条件判断

F:
<s:fielderror></s:fielderror>-----显示文件错误信息
<s:file></s:file>-----文件上传
<s:form action=""></s:form>-----获取相应form的值

G:
<s:generator separator="" val=""></s:generator>----和<s:iterator>标签一起使用

H:
<s:head/>-----在<head></head>里使用,表示头文件结束
<s:hidden></s:hidden>-----隐藏值

I:
<s:i18n name=""></s:i18n>-----加载资源包到值堆栈
<s:include value=""></s:include>-----包含一个输出,servlet或jsp页面
<s:inputtransferselect list=""></s:inputtransferselect>-----获取form的一个输入
<s:iterator></s:iterator>-----用于遍历集合

L:
<s:label></s:label>-----只读的标签

M:
<s:merge></s:merge>-----合并遍历集合出来的值

O:
<s:optgroup></s:optgroup>-----获取标签组
<s:optiontransferselect doubleList="" list="" doubleName=""></s:optiontransferselect>-----左右选择框

P:
<s:param></s:param>-----为其他标签提供参数
<s:password></s:password>-----密码输入框
<s:property/>-----得到'value'的属性
<s:push value=""></s:push>-----value的值push到栈中,从而使property标签的能够获取value的属性

R:

<s:radio list=""></s:radio>-----单选按钮
<s:reset></s:reset>-----重置按钮


S:
<s:select list=""></s:select>-----单选框
<s:set name=""></s:set>-----赋予变量一个特定范围内的值
<s:sort comparator=""></s:sort>-----通过属性给list分类
<s:submit></s:submit>-----提交按钮
<s:subset></s:subset>-----为遍历集合输出子集

T:
<s:tabbedPanel id=""></s:tabbedPanel>-----表格框
<s:table></s:table>-----表格
<s:text name=""></s:text>-----I18n文本信息
<s:textarea></s:textarea>-----文本域输入框
<s:textfield></s:textfield>-----文本输入框
<s:token></s:token>-----拦截器
<s:tree></s:tree>-----树
<s:treenode label=""></s:treenode>-----树的结构

U:
<s:updownselect list=""></s:updownselect>-----多选择框
<s:url></s:url>-----创建url

posted @ 2008-10-04 14:02 Loy Fu 阅读(291) | 评论 (0)编辑 收藏
1. 介绍
1.1 Model-View-Controller (MVC) 设计模式
FIXME - 需要一个对该模式一般性的介绍。(译注:可以参考机械工业出版社的《设计模式》。)
1.2 将MVC概念映射到Struts组件中
Struts 的体系结构实现了Model-View-Controller设计模式的概念,它将这些概念映射到web应用程序的组件和概念中.
这一体系结构中每个主要的组件都将在下面做详细的讨论。

1.3 Model: 系统状态和商业逻辑JavaBeans
基于MVC的系统中的 Model 部分可以细分为两个概念 -- 系统的内部状态, 能够改变状态的行为。用语法术语来说,我们可以把状态信息当作名词(事物),把行为当作动词(事物状态的改变)。
通常说来,你的应用程序将系统内部的状态表示为一组一个或多个的JavaBeans,使用属性(properties)来表示状态的细节。依赖于你的应用程序的复杂度,这些beans可以是自包含的(以某种方式知道怎样永久地保存它们的状态信息),或者可以是正面的(facades),知道当被请求时怎样从外部数据源(例如数据库)中取得信息。Entity EJBs通常也用来表示内部状态。

大型应用程序经常将系统可能的商业逻辑行为表示为可以被维护状态信息的beans调用的方法。举个例子,你有一个为每个当前用户保存在session中的购物车bean,里面是表示当前用户决定购买物品的属性。这个bean有一个checkOut()方法用来验证用户的信用卡,将定单发给库房以选择货品和出货。别的系统分别地表示同样的行为,或许使用Session EJBs。

在一些小型应用程序中,同样的行为又可能嵌入到作为Controller一部分的 Action 类中。这在逻辑非常简单或者并不想要在其它环境中重用这些商业逻辑时是恰当的。Struts框架支持所有这些方法,但建议将商业逻辑(“做什么”)和 Action 类(“决定做什么”)分离开。

1.4 View: JSP页面和表示组件
基于Struts的应用程序中的 View 部分通常使用JSP技术来构建。JSP页面包含称为“模版文本”的静态HTML(或XML)文本,加上插入的基于对特殊行为标记解释的动态内容。JSP环境包括了其用途由JSP规范来描述的一套标准的行为标记,例如 <jsp:useBean> 。另外,还有一个用来定义你自己标记的标准机制,这些自定义的标记组织在“定制标记库”中。
Struts包括了一个广阔的便于创建用户界面,并且充分国际化的定制标记库,与作为系统 Model 部分一部分的ActionForm beans美妙地相互配合。这些标记的使用将在后面做详细讨论。

除了JSP页面和其包含的行为及定制标记,商业对象经常需要能够基于它们在被请求时的当前状态将自己处理成HTML(或XML)。从这些对象处理过的输出可以很容易地使用 <jsp:include> 标准行为标记包括在结果的JSP页面中。

1.5 Controller: ActionServlet和ActionMapping
应用程序的 Controller 部分集中于从客户端接收请求(典型情况下是一个运行浏览器的用户),决定执行什么商业逻辑功能,然后将产生下一步用户界面的责任委派给一个适当的View组件。在Struts中,controller的基本组件是一个 ActionServlet 类的servlet。这个servlet通过定义一组映射(由Java接口 ActionMapping 描述)来配置。每个映射定义一个与所请求的URI相匹配的路径和一个 Action 类(一个实现 Action 接口的类)完整的类名,这个类负责执行预期的商业逻辑,然后将控制分派给适当的View组件来创建响应。
Struts也支持使用包含有运行框架所必需的标准属性之外的附加属性的 ActionMapping 类的能力。这允许你保存特定于你的应用程序的附加信息,同时仍可利用框架其余的特性。另外,Struts允许你定义控制将重定向到的逻辑名,这样一个行为方法可以请求“主菜单”页面(举例),而不需要知道相应的JSP页面的实际名字是什么。这个功能极大地帮助你分离控制逻辑(下一步做什么)和显示逻辑(相应的页面的名称是什么)。

2. 创建Model组件
2.1 概述
你用到的应用程序的需求文档很可能集中于创建用户界面。然而你应该保证每个提交的请求所需要的处理也要被清楚的定义。通常说来,Model 组件的开发者集中于创建支持所有功能需求的JavaBeans类。一个特殊应用要求的beans的精确特性依赖于具体需求变化会非常的大,但是它们通常可以分成下面讨论的几种类型。然而,首先对“范围”概念做一个简短的回顾是有用的,因为它与beans有关。
2.2 JavaBeans和范围
在一个基于web的应用程序中,JavaBeans可以被保存在(并从中访问)一些不同“属性”的集合中。每一个集合都有集合生存期和所保存的beans可见度的不同的规则。总的说来,定义生存期和可见度的这些规则被叫做这些beans的 范围 。JSP规范中使用以下术语定义可选的范围(在圆括号中定义servlet API中的等价物):
page - 在一个单独的JSP页面中可见的Beans,生存期限于当前请求。(service()方法中的局部变量) request - 在一个单独的JSP页面中可见的Beans,也包括所有包含于这个页面或从这个页面重定向到的页面或servlet。(Request属性)
session - 参与一个特定的用户session的所有的JSP和servlet都可见的Beans,跨越一个或多个请求。(Session属性)
application - 一个web应用程序的所有JSP页面和servlet都可见的Beans。(Servlet context属性)
记住同一个web应用程序的JSP页面和servlets共享同样一组bean集合是很重要的。例如,一个bean作为一个request属性保存在一个servlet中,就象这样:
MyCart mycart = new MyCart(...);
request.setAttribute("cart", mycart);
将立即被这个servlet重定向到的一个JSP页面使用一个标准的行为标记看到,就象这样:
<jsp:useBean id="cart" scope="request"
class="com.mycompany.MyApp.MyCart"/>
2.3 ActionForm Beans
Struts框架通常假定你已经为每一个你的应用程序中请求的输入创建了一个 ActionForm bean(即一个实现了 ActionForm 接口的类)。如果你在你的 ActionMapping 配置文件中定义了这样的beans(见“创建Controller组件”),Struts的controller servlet在调用适当的 Action 方法前将自动为你执行如下的服务:
用适当的关键字检查用户的session中是否有适当的类的bean的一个实例。
如果没有这样的session范围的bean,自动建立一个新的bean并添加到用户的session中。
对每个名字对应于bean中的一个属性的请求参数,调用相应的set方法。这个操作类似于当你以通配符“*”选择所有属性使用标准的JSP行为标记 <jsp:setProperty> 。
更新的ActionForm bean在被调用时将被传递给Acton类的perform()方法,以使这些值能够立即生效。
当你在写你的ActionForm beans时,记住以下的原则:
ActionForm 接口本身不需要特殊的实现方法。它是用来标识这些特定的beans在整个体系结构中的作用。典型情况下,一个ActionForm bean只包括属性的get方法和set方法,没有商业逻辑。
通常在一个ActionForm bean中只有很少的输入验证逻辑。这样的beans存在的主要理由是保存用户为相关的表单所输入的大部分近期值 -- 甚至在错误被检测到时 -- 这样同样的页面可以被重建,伴随有一组出错信息,这样用户仅仅需要纠正错误的字段。用户输入的验证应该在 Action 类中执行(如果是很简单的话),或者在适当的商业逻辑beans中执行。
为每个表单中出现的字段定义一个属性(用相关的getXxx()和setXxx()方法)。字段名和属性名必须按照JavaBeans的约定相匹配。例如,一个名为 username 的输入字段将引起 setUsername() 方法被调用。
你应该注意一个“表单”在这里讨论时的意义并不必须对应于用户界面中的一个单独的JSP页面。在很多应用程序中一个“表单”(从用户的观点)延伸至多个页面也是很平常的。想想看,例如,通常在安装新的应用程序时使用的导航安装程序的用户界面。Struts鼓励你定义一个包含所有字段属性的单独的ActionForm bean。不管字段实际上是显示在哪个页面上。同样的,同一表单的不同的页面应该提交到相同的Action类。如果你遵照这个建议,在大多数情况下,页面设计者可以重新组织不同页面中的字段而不需要改变处理逻辑。
2.4 系统状态Beans
系统的实际状态通常表示为一组一个或多个的JavaBeans类,其属性定义当前状态。例如,一个购物车系统包括一个表示购物车的bean,这个bean为每个单独的购物者维护,这个bean中包括(在其它事物之中)一组购物者当前选择购买的项目。分别地,系统也包括保存用户信息(包括他们的信用卡和送货地址)、可获得项目的目录和它们当前库存水平的不同的beans。
对于小规模的系统,或者对于不需要长时间保存的状态信息,一组系统状态beans可以包含所有系统曾经经历的特定细节的信息。或者经常是,系统状态beans表示永久保存在一些外部数据库中的信息(例如CustomerBean对象对应于表 CUSTOMERS 中的特定的一行),在需要时从服务器的内存中创建或清除。在大规模应用程序中,Entity EJBs也用于这种用途。

2.5 商业逻辑Beans
你应该把你的应用程序中的功能逻辑封装成对为此目的设计的JavaBeans的方法调用。这些方法可以是用于系统状态beans的相同的类的一部分,或者可以是在专门执行商业逻辑的独立的类中。在后一种情况下,你通常需要将系统状态beans传递给这些方法作为参数处理。
为了代码最大的可重用性,商业逻辑beans应该被设计和实现为它们不知道自己被执行于web应用环境中。如果你发现在你的bean中你必须import一个 javax.servlet.* 类,你就把这个商业逻辑捆绑在了web应用环境中。考虑重新组织事物使你的 Action 类(Controller任务的一部分,在下面描述)翻译所有从HTTP请求中请求被处理为对你的商业逻辑beans属性set方法调用的信息,然后可以发出一个对 execute() 的调用。这样的一个商业逻辑类可以被重用在除它们最初被构造的web应用程序以外的环境中。

依赖于你的应用程序的复杂度和范围,商业逻辑beans可以是与作为参数传递的系统状态beans交互作用的普通的JavaBeans,或者使用JDBC调用访问数据库的普通的JavaBeans。而对于较大的应用程序,这些beans经常是有状态或无状态的EJBs。

2.6 题外话: 访问关系数据库
很多web应用程序利用一个关系数据库(通过一个JDBC driver访问)来保存应用程序相关的永久数据。其它应用程序则使用Entity EJBs来实现这个目的,他们委派EJBs自己来决定怎样维护永久状态。如果你是使用EJBs来实现这个目的,遵照EJB规范中描述的客户端设计模式。
对于基于直接数据库访问的web应用程序,一个普通的设计问题是当需要访问低层数据库时怎样产生一个适当的JDBC连接对象。解决这个问题有几种方法 -- 以下原则描述了推荐的一种方法:

创建或得到一个允许一组数据库连接被多个用户共享的ConnectionPool类。Struts(当前)没有包括这样的一个类,但是有很多这样的类可以得到。
当应用程序初始化时,在应用程序展开(deployment)描述符中定义一个有一个“启动时加载”值的servlet。我们将把这个servlet叫做 启动 servlet。在大多数情况下,这个servlet不需要处理任何的请求,所以没有一个 <servlet-mapping> 会指向它。
在启动servlet的 init() 方法中,配置并初始化一个ConnectionPool类的实例,将其保存为一个servlet context属性(从JSP的观点看等同于一个application范围的bean)。通常基于传递给启动servlet初始化参数来配置联接缓冲池是很方便的。
在启动servlet的 destroy() 方法中,包含了释放联接缓冲池所打开的联接的逻辑。这个方法将在servlet容器结束这个应用程序的时候被调用。
当 Action 类需要调用一个需要数据库联接的商业逻辑bean中的方法(例如“insert a new customer”)时,将执行下面的步骤:
为这个web应用程序从servelt context属性中得到一个联接缓冲池对象。
调用联接缓冲池对象的 open() 方法来得到一个在 Action 类调用中使用的联接。
调用商业逻辑bean中合适的方法,将数据库联接对象作为一个参数传递给它。
调用分配的联接中的 close() 方法,这将引起这个联接为了以后其它请求的重用被返回到缓冲池中。
一个通常的编程错误是忘记了把数据库联接返回给缓冲池,这将最终导致用完所有的联接。一定要确信 Action 类的逻辑总是返回联接,甚至在商业逻辑bean抛出一个违例时。
遵照上面推荐的设计模式意味着你能够编写你的商业逻辑类而不需要担心它们怎样得到一个JDBC联接来使用-- 简单地在任何需要访问数据库的方法中包含一个Connection参数。当你的商业逻辑类在一个web应用程序中被利用时,分配和释放适当的联接是 Action 类的责任。当你使用相同的商业逻辑类时,例如,在一个批处理工作中,提供一个适当的联接是那个应用程序的责任(这不需要从缓冲池中获得,因为大多数批处理工作运行于一个单线程环境中)。
3. 创建View组件
3.1 概述
这一章集中于创建应用程序中的 View 组件的任务,主要使用JSP技术建立。特别的,Struts除了提供了与输入表单的交互外还提供了建立国际化应用程序的支持。几个其它的与View相关的主题也被简单地讨论。
3.2 国际化消息
几年之前,应用程序开发者能够考虑到仅仅支持他们本国的只使用一种语言(或者有时候是两种)和通常只有一种数量表现方式(例如日期、数字、货币值)的居民。然而,基于web技术的应用程序的爆炸性增长,以及将这些应用程序展开在Internet或其它被广泛访问的网络之上,已经在很多情况下使得国家的边界淡化到不可见。这种情况转变成为一种对于应用程序支持国际化(经常被称做“i18n”,因为18是字母“i”和字母“n”之间的字母个数)和本地化的需求。
Struts建立于Java平台之上为建立国际化和本地化的应用程序提供帮助。需要熟悉的关键概念是:

Locale - 基础的支持国际化的Java类是 java.util.Locale 。每个 Locale 代表一个特别的国家和语言选择(加上一个可选的语言变量),以及一套格式假定,例如数字和日期等等。
ResourceBundle - java.util.ResourceBundle 类提供支持多种语言消息的基本工具。查看文档中关于ResourceBundle 类以及你的JDK版本的文档包中关于国际化的更多内容。
PropertyResourceBundle - 一个 ResourceBundle 类的标准实现允许你使用与初始化properties文件同样的“name=value”语法来定义资源。这对于使用为用于一个web应用程序的消息准备资源包是非常方便的,因为这些消息通常都是面向文本的。
MessageFormat - java.text.MessageFormat 类允许你使用运行时指定的参数替换一个消息字符串中的一部分(在这种情况下,是一个从一个资源包得到的消息)。这在你创建一个句子的场合中是有用的,但是词会以不同的语言按照不同的顺序出现。消息中的占位符字符串{0}用第一个运行时参数替换,{1}用第二个运行时参数替换,以此类推。
MessageResources - Struts的类 org.apache.struts.util.MessageResources 使你能够将一套资源包视做一个数据库,并且允许你为一个特定的Locale(通常是与当前用户相对应)请求一个特定的消息,而不是为服务器运行在其中的缺省的Locale请求消息。
对于一个国际化的应用程序,遵照JDK文档包中国际化文档所描述的步骤来创建一个包含每种语言的消息的属性文件。下面举一个例子说明。
假设你的源代码建立在包 com.mycompany.mypackage 中,因此它保存于一个叫做(相对于你的源目录)com/mycompany/mypackage 的目录中。为创建一个叫做 com.mycompany.mypackage.MyResources 的资源包,你应该在目录 com/mycompany/mypackage 中创建下列文件:

MyResources.properties - 包含你的服务器的缺省语言的消息。如果你的缺省语言是英语,你可能有一个这样的条目:
prompt.hello=Hello
MyResources_xx.properties - 包含ISO语言编程为“xx”(查看ResourceBundle的Java文档页面得到一个当前列表的联接)的同样的消息。对于上面的消息的法语版,你可以有这个条目:
prompt.hello=Bonjour
你可以有你需要的任意多的语言的资源包文件。
当你在web应用程序展开描述符中配置controller servlet时,你需要在一个初始化参数中定义的一件事是应用程序的资源包的基础名。在上述的情况中,这应该是 com.mycompany.mypackage.MyResources 。
3.3 表单和FormBean的交互
大部分web开发者曾经使用HTML的标准性能来建立表单,例如使用 <input> 标记。用户希望交互程序具有一定的行为,这些期待中的一个与错误处理有关 -- 如果用户出现一个错误,应用程序应该允许他们仅仅修改需要修改的部分 -- 而不需要重新敲入当前页面或表单中的任何其它信息。
使用标准的HTML和JSP编程来完全实现这个期望是单调而繁重的。举例来说,一个用户名字段的输入元素看起来可以象是这样(在JSP中)

<input type="text" name="username"
value="<%= loginBean.getUsername() %>">
这很难敲对,会把没有编程概念的HTML开发者搞糊涂,并且会在HTML编辑器中造成问题。取而代之的是,Struts提供了一种全面的基于JSP 1.1的定制标记库功能的机制来建立表单。上面的情况使用Struts处理后将象是这样:
<struts:text name="username"/>
没有必要再显式地涉及到从中获得初始值的JavaBean。这将由框架自动处理。
3.3.1 使用Struts建立表单
一个完整的注册表单将演示Struts相对于直接使用HTML和标准的JSP功能怎样极大地减轻了处理表单的痛苦。考虑以下称为logon.jsp的页面(来自Struts的例子程序):



<%@ page language="java" %>
<%@ taglib uri="/WEB-INF/struts.tld" prefix="struts" %>

<html>
<head>
<title><struts:message key="logon.title"/></title>
<body bgcolor="white">

<struts:errors/>

<struts:form action="logon.do" name="logonForm"
type="org.apache.struts.example.LogonForm"/>
<table border="0" width="100%">
<tr>
<th align="right">
<struts:message key="prompt.username"/>
</th>
<td align="left">
<struts:text name="username" size="16"/>
</td>
</tr>
<tr>
<th align="right">
<struts:message key="prompt.password"/>
</th>
<td align="left">
<struts:password name="password" size="16"/>
</td>
</tr>
<tr>
<td align="right">
<struts:submit>
<struts:message key="button.submit"/>
</struts:submit>
</td>
<td align="right">
<struts:reset>
<struts:message key="button.reset"/>
</struts:reset>
</td>
</tr>
</table>
</struts:form>

</body>
</html>

下面的条目基于这个例子演示在Struts中处理表单的关键的特性:
taglib指令告诉JSP页面编译器从哪里找到Struts标记库的 标记库描述符 。在这种情况下,我们使用struts作为前缀来标识来自这个库中的标记,但是可以使用任何你想用的前缀。
这个页面使用了几个 message 标记来从一个包含有这个应用程序所有资源的 MessageResources 对象中查找国际化的消息字符串。为了让这个页面能够工作,以下的消息关键字必须在这些资源中被定义:
logon.title - 注册页面的标题
prompt.username - 一个 “Username:” 提示字符串
prompt.password - 一个 “Password:” 提示字符串
button.submit - “Submit”按钮的标签
button.reset - “Reset”按钮的标签
当用户注册时,应用程序可以在用户的session中保存一个 Locale 对象。这个 Locale 将用来选择适当语言的消息。这使得给用户一个切换语言的可选项实现起来变的容易了 -- 仅仅改变保存的 Locale 对象,所有的消息就会自动切换。
errors 标记显示由一个商业逻辑组件保存的任何出错消息,或者如果没有出错消息保存就什么都没有。这个标记将在下面做深入的描述。
form 标记基于指定的属性对一个HTML <form> 元素进行处理。它也将所有在这个表单中的字段与一个保存在关键字 logonForm 下的session范围的FormBean相关联。这个bean用来为所有的具有与bean中的属性名匹配的名字的输入字段提供初始值。如果适当的bean没有找到,一个新的bean将会被自动建立,使用指定的Java类名。
text 标记对一个类型为“text”的HTML <input> 元素进行处理。在这种情况下,占据浏览器屏幕的字符位置的数字也被指定。当页面被执行时,是相对应的bean的 username 属性的当前值(也就是 getUsername() 的返回值)。
password 标记使用方法类似。不同之处是当用户敲入他们的口令时浏览器将回应星号字符,而不是输入值。
submit 和 reset 标记在表单低部生成相应的按钮。每个按钮的文本标签使用 message 标记建立,同时带有提示,这样这些值就是国际化的。
3.3.2 输入字段类型支持
Struts为所有以下类型的输入字段定义了标记,带有与其相应的参考信息的超联接。
checkboxes
hidden 字段
password 输入字段
radio 按钮
reset 按钮
select 列表和嵌入的
options
submit 按钮
text 输入字段
textareas
在所有情况下,一个字段标记都必须嵌套在一个 form 标记中,这样字段才知道使用哪个bean来初始化显示的值。
3.3.3 其它有用的表示标记
在Struts的标记库中有几个其它的标记对于建立用户界面是有帮助的:
enumerate 为一个指定集合的每个元素重复一次标记体(可以是一个Enumeration,一个Hashtable,一个Vector或一个对象数组)。
getProperty 从指定的bean中得到指定的属性,并且在本页面的其余部分作为一个page范围的bean存在。这是访问一个被 enumerate 使用的集合的方便的方法。
ifAttributeExists 只有在一个指定的属性存在于一个指定的范围中时才对标记体求值。
ifAttributeMissing 只有在一个指定的属性不存在于一个指定的范围中时才对标记体求值。
ifParameterEquals 只有在一个指定的请求参数具有一个指定的值时才对标记体求值。
ifParameterNotEquals 只有在一个指定的请求参数不具有一个指定的值或者不存在时才对标记体求值。
ifParameterNotNull 只有在一个指定的请求参数包含在这个请求中并且长度大于0时才对标记体求值。
ifParameterNull 只有在一个指定的请求参数不包含在这个请求中或者长度等于0时才对标记体求值。
iterate 为一个指定集合中的每个元素重复一次标记体(可以是一个Collection,一个Iterator,一个Map,或者一个对象数组)。这个标记在Java2环境中代替了 enumerate 标记。
link 生成一个超联接,当没有cookie支持时自动应用URL编程来维护session状态。
parameter 处理指定请求参数的值,适当地过滤HTML中有特殊含义的字符。
property 显示一个表单中命名的bean属性 -- 在属性应该是只读时使用这个标记而不是 text 标记。
3.3.4 自动表单验证
除了上面描述的表单和bean的交互外,如果你的bean知道怎样验证它接收的输入字段,Struts还提供一种附加的机制。为了利用这个特性,使你的bean类实现 ValidatingActionForm 接口,而不是 ActionForm 接口。一个 ValidatingActionForm 增加了一个附加的方法签名:
public String[] validate()
对于一个被controller servlet在bean属性已经组装但是在相应的行为类的 perform() 方法被调用之前调用的方法,validate() 方法有以下可选项:
执行适当的验证发现没有错误 -- 返回 null 或者一个非0长度字符串数组,并且controller servlet将继续调用适当的 Action 类的 perform() 方法。
执行适当的验证发现有错误 -- 返回一个内容为应该被显示的出错消息关键字(进入应用程序的MessageResources 包)的字符串数组。controller servlet将作为适合于 <struts:errors> 标记使用的请求属性保存这个数组,并且将控制重定向回输入表单(由这个 ActionMapping 的 inputForm 属性标识)。
正如以前提到的,这个特性完全是可选的。如果你的form bean 仅仅实现了 ActionForm 接口,controller servlet将假设任何请求的验证由action类完成。
3.4 其它的表示技术
尽管你的应用程序的外表和感觉可以完全基于标准的JSP能力和Struts的定制标记库构建,你也应该考虑展开其它改进组件重用、减少管理负担或者减少出错的技术。在下面的部分讨论几个可选的技术。
3.4.1 特定于应用程序的定制标记
在使用Struts库提供的定制标记之外,很容易建立特定于你创建的应用程序的标记来帮助建立用户界面。Struts包括的例子程序用建立以下仅用于实现这个应用程序的标记演示了这个原则:
checkLogon - 检查一个特殊的会话对象的存在,如果不存在将控制重定向到注册页面。这是用来捕捉这样的情况,用户在你的应用程序执行的中间把一个页面做成书签并且试图跳过注册,或者用户的会话超时。
linkSubscription - 为一个详细的定单页面生成一个超联接,它将需要的主关键字值作为一个请求属性传递。这在列出与一个用户相关的定单并提供编辑或删除定单的联接时使用。
linkUser - 为一个用户的一个具体的页面生成一个超联接,它将它将需要的主关键字值作为一个请求属性传递。
这些标记的源代码在 src/example 目录中,在包 org.apache.struts.example 里,还带有一些其它的用在这个应用程序中的Java类。
3.4.2 有包含文件的页面组件
在一个JSP文件(包含定制标记和beans用来访问请求的动态数据)中创建完整的表示是一种非常普通的设计方法,在Struts包括的例子程序中被采用。然而很多应用程序要求在单独一个页面中显示你的应用程序的多个逻辑上独立的部分。
举例来说,一个入口应用程序可以在入口的主页面上有一些或者全部以下的功能:

访问这个入口的一个搜索引擎。
一个或更多的“提供新闻”的显示,含有按照用户的注册信息定制的感兴趣的标题。
访问与这个入口相关的讨论的主题。
如果你的入口提供免费邮件帐号,还要有一个“邮件等待”的提示。
如果你能够将工作划分开,分配不同的开发者去做不同的片段,那么这个站点不同片段的开发就会更加简单。然后,你可以使用JSP技术的 include 能力来将这些片段组合进一个单独的页面。有两种 include 可用,依赖于你希望输出的组合发生在什么时间:
include 指令 (<%@ include file="xxxxx" %>)在JSP页面被编译时处理。它用于包括不需要在请求时改变的HTML代码。它把包括进来的文本当作静态文本,很象C或C++中的 #include 指令。
include 行为 (<jsp:include page="xxxxx" flush="true" />)在请求时处理,并且是由服务器透明处理。这意味着你可以通过把它嵌套在一个类似ifParameterEquals的标记中有条件地执行include 。
3.4.3 图片处理组件
一些应用程序要求动态生成图片,就象一个股市报告站点的价格图一样。通常使用两种不同的方法来实现这个需求:
处理一个执行一个servlet请求的URL的超联接。这个servlet将使用一个图象库来生成图片,设置适当的content类型(例如 image/gif),并且将图片的字节流发送回浏览器。浏览器就会象从一个静态文件中接收到的一样显示图片。
处理HTML代码需要下载一个创建请求的图象的Java applet。你可以通过为在处理的代码中的这个applet设置适当的初始化参数配置这个图象,或者你可以让这个applet与服务器建立自己联接来接收这些参数。
4. 创建Controller组件
4.1 概述
现在我们理解了怎样构造你的应用程序的Model和View组件,现在是集中到 Controller 组件的时候了。Struts包括一个实现映射一个请求URI到一个行为类的主要功能的servlet。因此你的与Controller有关的主要责任是:
为每一个可能接收的逻辑请求写一个 Action 类(也就是,一个 Action 接口的实现)
写一个定义类名和与每个可能的映射相关的其它信息的 ActionMapping 类(也就是,一个 ActionMapping 接口的实现)
写行为映射配置文件(用XML)用来配置controller servlet。
为你的应用程序更新web应用程序展开描述符文件(用XML)用来包括必需的Struts组件。
给你的应用程序添加适当的Struts组件。
4.2 Action类
Action 接口定义一个单一的必须由一个 Action 类实现的方法,就象下面这样:
public ActionForward perform(ActionServlet servlet,
ActionMapping mapping,
ActionForm form,
HttpServletRequest request,
HttpServletResponse response)
throws IOException, ServletException;
一个 Action 类的目标是处理这个请求,然后返回一个标识JSP页面的 ActionForward 对象,控制应该重定向这个JSP页面以生成相应的响应。在 Model 2 设计模式中,一个典型的 Action 类将在它的 perform() 方法中实现下面的逻辑:
验证用户session的当前状态(例如,检查用户已经成功地注册)。如果 Action 类发现没有注册存在,请求应该重定向到显示用户名和口令用于注册的JSP页面。应该这样做是因为用户可能试图从“中间”(也就是,从一个书签)进入你的应用程序,或者因为session已经超时并且servlet容器创建了一个新的session。
如果验证还没有发生(由于使用一个实现 ValidatingActionForm 接口的form bean),验证这个 form bean 的属性是必须的。如果发现一个问题,当作一个请求属性保存合适的出错信息关键字,然后将控制重定向回输入表单这样错误可以被纠正。
执行要求的处理来处理这个请求(例如在数据库里保存一行)。这可以用嵌入 Action 类本身的代码来完成,但是通常应该调用一个商业逻辑bean的一个合适的方法来执行。
更新将用来创建下一个用户界面页面的服务器端对象(典型情况下是request范围或session范围beans,定义你需要在多长时间内保持这些项目可获得)。
返回一个标识生成响应的JSP页面的适当的 ActionForward 对象,基于新近更新的beans。典型情况下,你将通过在你接收到的 ActionMapping 对象(如果你使用一个局部于与这个映射上的逻辑名)或者在controller servlet 本身(如果你使用一个全局于应用程序的逻辑名)上调用 findForward() 得到一个对这样一个对象的引用。
当为 Action 类编程时要记住的设计要点包括以下这些:
controller servlet仅仅创建一个你的 Action 类的实例,用于所有的请求。这样你需要编写你的 Action 类使其能够在一个多线程环境中正确运行,就象你必须安全地编写一个servlet的 service() 方法一样。
帮助线程安全编程的最重要的原则就是在你的 Action 类中仅仅使用局部变量而不是实例变量。局部变量创建于一个分配给(由你的JVM)每个请求线程的栈中,所以没有必要担心会共享它们。
尽管不应该,代表你的系统中Model部分的的beans仍有可能抛出违例。你应该在你的 perform() 方法的逻辑中捕捉所有这样的违例,并且通过执行以下语句将它们记录在应用程序的日志文件中(包括相应的栈跟踪信息):
servlet.log("Error message text", exception);
作为一个通用的规则,分配很少的资源并在来自同一个用户(在用户的session中)的请求间保持它们会导致可伸缩性的问题。你应该在将控制重定向到适当的View组件前努力释放这样的资源(例如数据库联接) -- 甚至在你调用的一个bean抛出了一个违例时。
另外,你将会想要防止出现非常大的 Action 类。最简单的实现途径是将你的功能逻辑嵌入到 Action 类本身,而不是将其写在独立的商业逻辑beans中。除了使 Action 类难于理解和维护外,这种方法也使得难于重用这些商业逻辑代码,因为代码被嵌入到一个组件(Action 类)中并被捆绑运行于web应用程序环境中。
包括在Struts中的例子程序某种程度上延伸了这个设计原则,因为商业逻辑本身是嵌入到 Action 类中的。这应该被看作是在这个样本应用程序设计中的一个bug,而不是一个Struts体系结构中的固有特性,或者是一个值得仿效的方法。

4.3 ActionMapping实现
为了成功地运行,Struts的controller servlet需要知道关于每个URI该怎样映射到一个适当的 Action 类的几件事。需要了解的知识封装在一个叫做 ActionMapping 的Java接口中,它有以下属性:
actionClass - 用于这个映射的 Action 类完整的Java类名。第一次一个特定的映射被使用,一个这个类的实例将被创建并为以后重用而保存。
formAttribute - session范围的bean的名字,当前的这个映射的 ActionForm 被保存在这个bean之下。如果这个属性没有被定义,没有 ActionForm 被使用。
formClass - 用于这个映射的 ActionForm 类完整的Java类名。如果你在使用对form beans的支持,这个类的一个实例将被创建并保存(在当前的用户会话中)
path - 匹配选择这个映射的请求的URI路径。看下面如何匹配的例子。
Struts在一个叫做 ActionMappingBase 的类中包括了一个 ActionMapping 接口的方便的实现。如果你不需要为你自己的映射定义任何附加的属性,尽管把这个类作为你的 ActionMapping 类好了,就向下面部分描述的那样配置。然而,定义一个 ActionMapping 实现(多半是扩展 ActionMappingBase 类)来包含附加的属性也是可能的。controller servlet知道怎样自动配置这些定制属性,因为它使用Struts的Digester模块来读配置文件。
包括在Struts的例子程序中,这个特性用来定义两个附加的属性:

failure - 如果Action类检测到它接收的输入字段的一些问题,控制应该被重定向到的上下文相关的URI。典型情况下是请求发向的JSP页面名,它将引起表单被重新显示(包含Action类设置的出错消息和大部分最近的来自ActionForm bean的输入值)。
success - 如果Action类成功执行请求的功能,控制应该被重定向到的上下文相关的URI。典型情况下是准备这个应用程序的会话流的下一个页面的JSP页面名。
使用这两个额外的属性,例子程序中的 Action 类几乎完全独立于页面设计者使用的实际的JSP页面名。这个页面可以在重新设计时被重命名,然而几乎不会影响到 Action 类本身。如果“下一个”JSP页面的名字被硬编码到 Action 类中,所有的这些类也需要被修改。
4.4 Action映射配置文件
controller servlet怎样知道你想要得到的映射?写一个简单地初始化新的 ActionMapping 实例并且调用所有适当的set方法的小的Java类是可能的(但是很麻烦)。为了使这个处理简单些,Struts包括一个Digester模块能够处理一个想得到的映射的基于XML的描述,同时创建适当的对象。看 API 文档 以获得关于Digester更多的信息。
开发者的责任是创建一个叫做 action.xml 的XML文件,并且把它放在你的应用程序的WEB-INF目录中。(注意这个文件并不需要 DTD,因为实际使用的属性对于不同的用户可以是不同的)最外面的XML元素必须是<action-mappings>,在这个元素之中是嵌入的0个或更多的 <action> 元素 -- 每一个对应于你希望定义的一个映射。

来自例子程序的 action.xml 文件包括“注册”功能的以下映射条目,我们用来说明这个需求:




<action-mappings>

<forward name="logon" path="/logon.jsp"/>

<action path="/logon"
actionClass="org.apache.struts.example.LogonAction"
formAttribute="logonForm"
formClass="org.apache.struts.example.LogonForm"
inputForm="/logon.jsp">
<forward name="success" path="/mainMenu.jsp"/>
</action>

</action-mappings>

就象你所看到的,这个映射匹配路径 /logon (实际上,因为例子程序使用扩展匹配,你在一个JSP页面指定的请求的URI结束于/logon.do)。当接收到一个匹配这个路径的请求时,一个 LogonAction 类的实例将被创建(仅仅在第一次)并被使用。controller servlet将在关键字 logonForm 下查找一个session范围的bean,如果需要就为指定的类创建并保存一个bean。
这个 action 元素也定义了一个逻辑名“success”,它在 LogonAction 类中被用来标识当一个用户成功注册时使用的页面。象这样使用一个逻辑名允许将 action 类隔离于任何由于重新设计位置而可能发生的页面名改变。

这是第二个在任何 action 之外宣告的 forward 元素,这样它就可以被所有的action全局地获得。在这个情况下,它为注册页面定义了一个逻辑名。当你调用 mapping.findForward() 时在你的 action 代码中,Struts首先查找这个action本地定义的逻辑名。如果没有找到,Struts会自动为你查找全局定义的逻辑名。

4.5 Web应用程序展开描述符
设置应用程序最后的步骤是配置应用程序展开描述符(保存在文件WEB-INF/web.xml中)以包括所有必需的Struts组件。作为一个指南使用例子程序的展开描述符,我们看到下面的条目需要被创建或修改。
4.5.1 配置Action Servlet实例
添加一个条目定义action servlet本身,同时包括适当的初始化参数。这样一个条目看起来象是这样:




<servlet>
<servlet-name>action</servlet-name>
<servlet-class>org.apache.struts.action.ActionServlet</servlet-class>
<init-p
aram>
<param-name>application</param-name>
<param-value>org.apache.struts.example.ApplicationResources</param-value>
</init-param>
<init-param>
<param-name>config</param-name>
<param-value>/WEB-INF/action.xml</param-value>
</init-param>
<init-param>
<param-name>debug</param-name>
<param-value>2</param-value>
</init-param>
<init-param>
<param-name>mapping</param-name>
<param-value>org.apache.struts.example.ApplicationMapping</param-value>
</init-param>
<load-on-startup>2</load-on-startup>
</servlet>

controller servlet支持的初始化参数在下面描述,拷贝自 ActionServlet 类的 Javadocs 。方括号描述如果你没有为那个初始化参数提供一个值时假设的缺省值。
application - 应用程序资源包基类的Java类名。[NONE].
config - 包含配置信息的XML资源的上下文相关的路径。[/WEB-INF/action.xml]
debug - 这个servlet的调试级别,它控制记录多少信息到日志中。[0]
digester - 我们在 initMapping() 中利用的Digester的调试级别,它记录到System.out而不是servlet的日志中。[0]
forward - 使用的ActionForward实现的Java类名。[org.apache.struts.action.ActionForward]
mapping - 使用的ActionMapping实现的Java类名。[org.apache.struts.action.ActionMappingBase]
nocache - 如果设置为 true,增加HTTP头信息到所有响应中使浏览器对于生成或重定向到的任何响应不做缓冲。[false]
null - 如果设置为 true,设置应用程序资源使得如果未知的消息关键字被使用则返回 null。否则,一个包括不欢迎的消息关键字的出错消息将被返回。[true]
4.5.2 配置Action Servlet映射
有两种通常的方法来定义将被controller servlet处理的URL -- 前缀匹配和扩展匹配。每种方法的一个适当的映射条目将在下面被描述。
前缀匹配意思是你想让所有以一个特殊值开头(在上下文路径部分之后)的URL传递给这个servlet。这样一个条目看起来可以象是这样:

<servlet-mapping>
<servlet-name>action</servlet-name>
<url-pattern>/execute/*</url-pattern>
</servlet-mapping>
它意味着一个匹配前面描述的 /logon 路径的请求的URL看起来象是这样:
http://www.mycompany.com/myapplication/execute/logon
这里 /myapplicationis 是你的应用程序展开所在的上下文路径。
另一方面,扩展映射基于URL以一个跟着定义的一组字符的句点结束的事实而将URL匹配到action servlet 。例如,JSP处理servlet映射到 *.jsp 模式这样它在每个JSP页面请求时被调用。为了使用 *.do 扩展(它意味着“做某件事”)映射条目看起来应该象是这样:

<servlet-mapping>
<servlet-name>action</servlet-name>
<url-pattern>*.do</url-pattern>
</servlet-mapping>
并且一个匹配以前描述的 /logon 路径的请求的URI可以看起来象是这样:
http://www.mycompany.com/myapplication/logon.do
4.5.3 配置Struts标记库
下一步,你必须添加一个定义Struts标记库的条目。这个条目看起来应该象是这样:
<taglib>
<taglib-uri>/WEB-INF/struts.tld</taglib-uri>
<taglib-location>/WEB-INF/struts.tld</taglib-location>
</taglib>
它告诉JSP系统到哪里去找这个库的标记库描述符(在你的应用程序的WEB-INF目录,而不是在外部互联网上的某个地方)。
4.5.4 添加Struts组件到你的应用程序中
为了在你的应用程序运行时使用Struts,你必须将 struts.tld 文件拷贝到你的 WEB-INF 目录,将 struts.jar 文件拷贝到你的 WEB-INF/lib 。 ?

posted @ 2008-10-04 13:59 Loy Fu 阅读(124) | 评论 (0)编辑 收藏

一个老师教许多学生,一个学生被许多老师教,一个学生有好多书,同一种书被许多同学拥有.
要查询教拥有书"a"的学生的老师!

Hql语句:

SELECT t FROM Teacher t join t.students s join s.books b where b.name = 'a' 

解释:t.students s中s并不是集合的意思,而是t的students对象的表别名,join t.students s这个hql,hibernate会翻译成两个表的内连接关系

错误写法:

SELECT t FROM teacher t where t.students.books.name = 'a' 

其实道理是很显然的,t.students是一个Set,那么这个Set怎么可能有books这样的属性呢?同理books.name也不对,所以使用表间连接并给出别名t.students s,此时的对象s才有books属性,所以可以写s.books b,最后使用b.name限制查询b.name = 'a'. 

另外一种写法:

SELECT t FROM Teacher t,Student s,Book b where s.id in elements(t.students) and b.id in elements(s.books)
这种方法没有出错!不过这种方式要用子查询!

posted @ 2008-10-03 18:26 Loy Fu 阅读(6733) | 评论 (1)编辑 收藏
     摘要: Spring 2.0 中   初始化设置 保证你使用的是Java 5 (EJB 3.0 中 JPA 的先决条件). 从 https://glassfish.dev.java.net/downloads/persistence/JavaPersistence.html 下载 glassfish JPA jar (注意: 我使用的是 “V2_bu...  阅读全文
posted @ 2008-10-03 15:01 Loy Fu 阅读(751) | 评论 (0)编辑 收藏
ext在线API  http://www.ajaxjs.com/docs/
posted @ 2008-10-03 02:22 Loy Fu 阅读(1728) | 评论 (1)编辑 收藏
store.on('load', function(_store, _records, _options){
    var title = _records[0].get('n_ttitle');
    var content = _records[0].get('n_content');
    p.setTitle(title);
    p.html = content;
    p.doLayout();
});
posted @ 2008-10-03 02:20 Loy Fu 阅读(195) | 评论 (0)编辑 收藏