Java豆技术站点 http://javadou.com Java Sat, 20 Mar 2010 02:44:57 +0000 http://wordpress.org/?v=2.9.2 en hourly 1 spring aop 初探 http://javadou.com/spring-aop-550/ http://javadou.com/spring-aop-550/#comments Sat, 20 Mar 2010 02:44:57 +0000 阿超 http://javadou.com/?p=550 spring aop 初探了解 通知，切点，目标对象，代理对象

1.建一个application工程aopTest

2.导入相应的包（这里用的spring2.5.X）

3.创建目标类LogTarget

public class LogTarget {
	public void login(){
		System.out.println("login is run");
	}
}

4.创建通知类LogAdvice

import java.lang.reflect.Method;

import org.springframework.aop.MethodBeforeAdvice;

public class LogAdvice implements MethodBeforeAdvice{

	@Override
	public void before(Method arg0, Object[] arg1, Object arg2)
			throws Throwable {
		// TODO Auto-generated method stub
		System.out.println("befor is run");
	}

}

5.配置applicationContext.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xmlns:aop="http://www.springframework.org/schema/aop"
	xmlns:tx="http://www.springframework.org/schema/tx"
	xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
		http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd
		http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd">
	<!-- 目标对象 -->
	<bean id="logTarget" class="LogTarget"/>
	<!-- 通知 -->
	<bean id="logAdvice" class="LogAdvice"/>
	<!-- 切入点 -->
	<bean id="logPointCutAdvisor" class="org.springframework.aop.support.RegexpMethodPointcutAdvisor">
		<property name="advice">
			<ref bean="logAdvice"/>
		</property>
		<property name="pattern">
			<value>.*login.*</value>
		</property>
	</bean>
	<!-- 代理对象 -->
	<bean id="logProxy" class="org.springframework.aop.framework.ProxyFactoryBean">
		<property name="target">
			<ref bean="logTarget"/>
		</property>
		<property name="interceptorNames">
			<list>
				<value>logPointCutAdvisor</value>
			</list>
		</property>
	</bean>
</beans>

6.编写测试类TestMain

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.FileSystemXmlApplicationContext;

public class TestMain {
	public static void main(String[] args) {
		ApplicationContext ctx = new FileSystemXmlApplicationContext(
				"src/applicationContext.xml");
		LogTarget logtarget=(LogTarget)ctx.getBean("logProxy");
		logtarget.login();
	}
]]> http://javadou.com/spring-aop-550/feed/ 1 jQuery 选择器的使用正则强大功能的jQuery 选择器 http://javadou.com/jquery-xuan-ze-566/ http://javadou.com/jquery-xuan-ze-566/#comments Fri, 19 Mar 2010 08:01:31 +0000 阿超 http://javadou.com/?p=566 一 基本选择器

$(“input“) :选择所有是input标签的元素

$(“#input1″):选择id为input1的元素

$(“.acss”):选择所有包含acss 这个css类样式的

<body>
<a href=”">link</a>
<input id=”input1″>
<input id=”Text1″>
<input id=”Text2″ >
<script>
var oo = $(“input”); //oo是以上3个的集合
var pp = $(“#input1″);//pp是第一个
var qq = $(“.acss”);//qq 是前两个的集合
</script>
</body>

可以用以上3个尽兴组合式的查询

var ww = $(“input.acss”); //选择具有acss的input标签元素
var ee = $(“input#Text1.acss”);//选择具有acss 的 id为 Text1的 标签为input的元素

二、子选择器

父节点和直接子节点用(>)隔开，即实现子选择器方式

<p>
<a href=”" id=”a1″></a>
<a href=”"></a>
<a href=”"></a>
<a href=”"></a>
<a href=”"></a>
<a href=”"></a>
<a href=”"></a>
</p>
<p>
<a href=”" id=”a2″></a>
<a href=”"></a>
<a href=”"></a>
<a href=”"></a>
<a href=”"></a>
<a href=”"></a>
<a href=”"></a>
</p>
<script>
var oo = $(“p a “); //选择了p下面的所有的a
var pp = $(“p>a”); //选择了2个a元素 ，id为a1 和a2
var qq = $(“p.acss a”); //选择了id为a1的元素
</script>

三、特征选择器

根据元素特征进行选择 a[href^=http://]

<div>
<input id=”Text3″ name=”myInput” />
<input id=”Text5″ name=”myput” />
<input id=”Text4″ name=”yourInput” />
<a id=”a3″ href=”http://www.baidu.com”></a>
<a id=”a4″ href=”www.baidu.com”></a>
</div>
<script>
var oo = $(“a[href^=http://]“); //选择href以 http:// 开头的a。a3选中
var pp = $(“input[name$=Input]“); //选择name以 Input 结尾的input 。Text3，Text4选中
var qq = $(“a[href*=com]“); //选择href以 包含com的a 。a3，a4选中
var ww = $(“input[id=Text3]“); //选择正好等于的

</script>

另外 jQuery还提供了 has方法，如上面例子中

div:has(input) 含义是。选择包含input的所有div

注意： div input 是选择的是div中的所有input 元素

四、位置选择器

位置选择器主要是根据元素的位置进行选择，

div a:first 返回页面第一个在div中的a

div a last 返回页面最后一个在div中的a

div odd 返回页面偶数位置的div

div even 返回页面奇数位置的idv

div first-child 返回div 中第一个子选择

div last-child 返回div 中最后一个子选择

only-child 没有兄弟节点的元素

nth-child(n)：第n个子节点

eq(n) 第n个匹配元素

gt(n) n之后的匹配元素 不包含

lt(n) n之前的匹配元素 不包含

五、jQuery自定义选择：

名称 说明 解释
:input 匹配所有 input, textarea, select 和 button 元素 查找所有的input元素:
$(“:input”)
:text 匹配所有的文本框 查找所有文本框:
$(“:text”)
:password 匹配所有密码框 查找所有密码框:
$(“:password”)
:radio 匹配所有单选按钮 查找所有单选按钮
:checkbox 匹配所有复选框 查找所有复选框:
$(“:checkbox”)
:submit 匹配所有提交按钮 查找所有提交按钮:
$(“:submit”)
:image 匹配所有图像域 匹配所有图像域:
$(“:image”)
:reset 匹配所有重置按钮 查找所有重置按钮:
$(“:reset”)
:button 匹配所有按钮 查找所有按钮:
$(“:button”)
:file 匹配所有文件域 查找所有文件域:
$(“:file”)
名称 说明 解释
:enabled 匹配所有可用元素 查找所有可用的input元素:
$(“input:enabled”)
:disabled 匹配所有不可用元素 查找所有不可用的input元素:
$(“input:disabled”)
:checked 匹配所有选中的被选中元素(复选框、单选框等，不包括select中的option) 查找所有选中的复选框元素:
$(“input:checked”)
:selected 匹配所有选中的option元素 查找所有选中的选项元素:
$(“select option:selected”)
]]> http://javadou.com/jquery-xuan-ze-566/feed/ 0 Struts2标签iterator介绍，iterator循环标签 http://javadou.com/struts2-iterator-iterator-each-565/ http://javadou.com/struts2-iterator-iterator-each-565/#comments Fri, 19 Mar 2010 02:53:45 +0000 阿超 http://javadou.com/?p=565

用于遍历集合（java.util.Collection）或枚举值（java.util.Iterator）。

参数：

名称 必需 默认 类型 描述
status 否 String 如果设置此参数，一个IteratorStatus的实例将会压入每个遍历的堆栈
value 否 Object/String 要遍历的可枚举的（iteratable）数据源，或者将放入新列表（List）的对象
id 否 Object/String 用来标识元素的id。在UI和表单中为HTML的id属性

例子：

<%@ page contentType=”text/html; charset=UTF-8″ %>
<%@ page import=”java.util.List” %>
<%@ page import=”java.util.ArrayList” %>
<%@ taglib prefix=”s” uri=”/struts-tags” %>

<!DOCTYPE HTML PUBLIC “-//W3C//DTD HTML 4.01 Transitional//EN”>
<%
List list = new ArrayList();
list.add(“Max”);
list.add(“Scott”);
list.add(“Jeffry”);
list.add(“Joe”);
list.add(“Kelvin”);
request.setAttribute(“names”, list);
%>
<html>
<head>
<title>Iterator</title>
</head>
<body>
<h3>Names: </h3>
<!–
1、此处的空property元素用于获得当前iterator的值
2、status被设成stuts，在iterator的里面就可以通过#stuts取得IteratorStatus的对象。 IteratorStatus类包含当前序号信息，如是否第一个或最后一个，是否为奇数序号。这些信息在我们做格式化的时候，显得非常有用。
–>
<ol>
<s:iterator value=”#request.names” status=”stuts”>
<s:if test=”#stuts.odd == true”>
<li>White <s:property /></li>
</s:if>
<s:else>
<li style=”background-color:gray”><s:property /></li>
</s:else>
</s:iterator>
</ol>
</body>
</html>

在struts2中,iterator标签是很好用的,但也要注意一下.举个例子,
如果要在每行中只显示两条记录,这个经常用到的例子来的了，可以这样用:
<table width=”800px” align=”center”>
<tr>
<s:iterator value=”songs” status=”st”>
<td>
<input type=”checkbox” name=”songIds” id=”<s:property value=’id’/>” value=”<s:property value=’id’/>”><label for=”<s:property value=’id’/>”>

<s:property value=”name”/>
</td>
<s:if test=”#st.modulus(2)==0″>
<s:if test=”#st.last”>
</tr></s:if>
<s:else>
</tr><tr></s:else>
</s:if>
</s:iterator>
</table>
这里无非就是要注意   <s:if test=”#st.modulus(2)==0″>
来判断整除2是否为0,(也可以用<s:if test=”#st.getIndex()%2==0)
并且注意如下的使用 #st.last,判断是否到了最后一条记录,并且注意:
iterator标签有如下方法：
boolean isEven() 当前迭代元素索引是否为偶数；
boolean isOdd() 当前迭代元素索引是否为奇数；
boolean isLast() 是否为最后一条元素；
boolean isFirst() 是否为第一条元素。
有以上元素，那么判断何时加入tr就非常方便。

]]> http://javadou.com/struts2-iterator-iterator-each-565/feed/ 1 Spring @AspectJ 实现AOP 入门例子 http://javadou.com/spring-aspectj-aop-demo-551/ http://javadou.com/spring-aspectj-aop-demo-551/#comments Fri, 19 Mar 2010 02:43:51 +0000 阿超 http://javadou.com/?p=551 Spring @AspectJ 实现AOP 入门例子
OP的作用这里就不再作说明了，下面开始讲解一个很简单的入门级例子。

引用一个猴子偷桃，守护者守护果园抓住猴子的小情节。

1、猴子偷桃类（普通类）：

package com.samter.common;   

/**
* 猴子
* @author Administrator
*
*/
public class Monkey {   

    public void stealPeaches(String name){
         System.out.println("【猴子】"+name+"正在偷桃...");
     }
}

2、守护者类（声明为Aspect）：

package com.samter.aspect;   

import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;   

/**
* 桃园守护者
* @author Administrator
*
*/  

@Aspect
public class Guardian {   

    @Pointcut("execution(* com.samter.common.Monkey.stealPeaches(..))")
    public void foundMonkey(){}   

    @Before(value="foundMonkey()")
    public void foundBefore(){
         System.out.println("【守护者】发现猴子正在进入果园...");
     }   

    @AfterReturning("foundMonkey() && args(name,..)")
    public void foundAfter(String name){
         System.out.println("【守护者】抓住了猴子,守护者审问出了猴子的名字叫“"+name+"”...");
     }   

}

3、XML配置文件：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
        xmlns:aop="http://www.springframework.org/schema/aop"
        xsi:schemaLocation="

http://www.springframework.org/schema/beans

http://www.springframework.org/schema/beans/spring-beans-2.0.xsd

http://www.springframework.org/schema/aop

        http://www.springframework.org/schema/aop/spring-aop-2.0.xsd"
>   

     <!-- 定义Aspect -->
     <bean id="guardian" class="com.samter.aspect.Guardian" />   

     <!-- 定义Common -->
     <bean id="monkey" class="com.samter.common.Monkey" />   

     <!-- 启动AspectJ支持 -->
     <aop:aspectj-autoproxy />   

</beans>

4、测试类：

package com.samter.common;   

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;   

public class Main {   

    public static void main(String[] args) {
         ApplicationContext context = new ClassPathXmlApplicationContext("config.xml");
         Monkey monkey = (Monkey) context.getBean("monkey");
        try {
             monkey.stealPeaches("孙大圣的大徒弟");
         }
        catch(Exception e) {}
     }   

}

5、控制台输出：

Java代码

【守护者】发现猴子正在进入果园…

【猴子】孙大圣的大徒弟正在偷桃…

【守护者】抓住了猴子,守护者审问出了猴子的名字叫“孙大圣的大徒弟”…

解说：1写了一个猴子正在偷桃的方法。

2写了一个标志为@Aspect的类，它是守护者。它会在猴子偷桃之前发现猴子，并在猴子偷桃之后抓住猴子。

原理：A、@Aspect的声明表示这是一个切面类。

B、@Pointcut使用这个方法可以将com.samter.common.Monkey.stealPeaches(..)方法声明为poincut即切入点。作用,在stealPeaches方法被调用的时候执行2的foundMonkey方法。其中execution是匹配方法执行的切入点，也就是spring最常用的切入点定义方式。

C、@Before(value=”foundMonkey()”)：@Before声明为在切入点方法执行之前执行，而后面没有直接声明切入点，而是value=”foundMonkey()”，是因为如果@afterReturning等都有所改动的时候都必须全部改动，所以统一用Pointcut的foundMonkey代替，这样子有改动的时候仅需改动一个地方。其他@AfterReturning类同。

3是xml配置文件，里面有具体的注释。

特别说明：Guardian类里面的@Pointcut(“execution(* com.samter.common.Monkey.stealPeaches(..))”)，如果stealPeaches有参数则..表示所有参数，@AfterReturning(“foundMonkey() && args(name,..)”)的&& args(name,..)可以获取切入点方法stealPeaches的参数。

总结：这里列举了一个简单的例子，但是不难引申到应用中，当你写一个登陆系统的时候，你或许要记录谁成功登陆了系统，谁登陆系统密码错误等等的信息，这样子你用切面是再合适不过的了，总之当你的事务逻辑都设计到日志、安全检查、事务管理等等共同的内容的时候，用切面是要比你没有一个事务逻辑类都有相关代码或者相关引用好得多。

]]> http://javadou.com/spring-aspectj-aop-demo-551/feed/ 0 struts 整合flex 的一个简单示例(使用Httpservice) http://javadou.com/flex-struts-httpservice-demo-546/ http://javadou.com/flex-struts-httpservice-demo-546/#comments Fri, 19 Mar 2010 02:42:37 +0000 阿超 http://javadou.com/?p=546 struts 整合flex 的一个简单示例(使用Httpservice)
关于在Eclipse下 flex整合java的配置请参考： http://aaacd.blog.hexun.com/15758049_d.html

这里是一个flex整合struts的一个基本的例子

1. testFlex10.mxml

<?xml version="1.0" encoding="utf-8"?>
<mx:Application xmlns:mx="http://www.adobe.com/2006/mxml"
    layout="absolute"
    backgroundColor="#FFFFFF"
    backgroundAlpha="0" horizontalCenter="true" >
<mx:HTTPService id="info" url="test.do">
<mx:request>
<username>
    {userId.text}
</username>
<userpwd>
    {password.text}
</userpwd>
</mx:request>
</mx:HTTPService>
<mx:TitleWindow id ="loginWindow" xmlns:mx="http://www.adobe.com/2006/mxml" title="Logon" x="350" y="80">
<mx:Form>
<mx:FormItem label="LUserId" required="true">
<mx:TextInput id="userId" width="150">
</mx:TextInput>
</mx:FormItem>
<mx:FormItem label="LPassword" required="true">
<mx:TextInput id="password"  width="150"/>
</mx:FormItem>
<mx:FormItem>
<mx:HBox horizontalGap="30">
<mx:Button label="Logon" click="info.send();" />
<mx:Button label="Cancel" click="info.send();"/>
</mx:HBox>
</mx:FormItem>
</mx:Form>
</mx:TitleWindow>
<mx:DataGrid dataProvider="{info.lastResult.userinfo.user}" width="60%" x="160" y="300" >
<mx:columns>
<mx:Array>
<mx:DataGridColumn headerText="姓名" dataField="username"/>
<mx:DataGridColumn headerText="密码" dataField="userpwd"/>
<mx:DataGridColumn headerText="邮件" dataField="useremail"/>
<mx:DataGridColumn headerText="年龄" dataField="userage"/>
</mx:Array>
</mx:columns>
</mx:DataGrid>
</mx:Application>

核心代码：

<mx:HTTPService id="info" url="test.do">
<mx:request>
<username>
    {userId.text}
</username>
<userpwd>
    {password.text}
</userpwd>
</mx:request>
</mx:HTTPService>

以及

dataProvider=”{info.lastResult.userinfo.user}”

2.struts.config.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE struts-config PUBLIC "-//Apache Software Foundation//DTD Struts Configuration 1.2//EN" "http://struts.apache.org/dtds/struts-config_1_2.dtd">
<struts-config>
  <data-sources />
  <form-beans >
    <form-bean name="testForm" type="com.yourcompany.struts.form.TestForm" />
  </form-beans>
  <global-exceptions />
  <global-forwards />
  <action-mappings >
    <action
      attribute="testForm"
      input="/form/test.jsp"
      name="testForm"
      path="/test"
      scope="request"
      type="com.yourcompany.struts.action.TestAction" >
      <forward name="success" path="/MyJsp.jsp"></forward>
</action>
  </action-mappings>
  <message-resources parameter="com.yourcompany.struts.ApplicationResources" />
</struts-config>

3.Action: TestAction.java

package com.yourcompany.struts.action;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.apache.struts.action.Action;
import org.apache.struts.action.ActionForm;
import org.apache.struts.action.ActionForward;
import org.apache.struts.action.ActionMapping;
import com.yourcompany.struts.form.TestForm;
public class TestAction extends Action {
 public ActionForward execute(ActionMapping mapping, ActionForm form,
   HttpServletRequest request, HttpServletResponse response) {
  TestForm testForm = (TestForm) form;// TODO Auto-generated method stub
  String name = testForm.getUsername();
  System.out.println("fadf : " + name);
  return (mapping.findForward("success"));
 }
}

4. MyJsp.jsp

<%@page import="
                java.util.List"%>
<%
response.setContentType("text/xml");
out.println("<?xml version=\"1.0\" encoding=\"utf-8\"?>");
out.println("<userinfo>");
        out.println("<user userId=\""+3123+"\">");
        out.println("<username>"+42314+"</username>");
        out.println("<userpwd>"+3123+"</userpwd>");
        out.println("<useremail>"+4231+"</useremail>");
        out.println("<userage>"+2+"</userage>");
        out.println("<regdate>"+4231+"</regdate>");
        out.println("</user>");
out.println("</userinfo>");
%>

本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/adriano86426/archive/2009/02/23/3928454.aspx

]]> http://javadou.com/flex-struts-httpservice-demo-546/feed/ 0 数据库的几种分页介绍 http://javadou.com/page-database-sql-547/ http://javadou.com/page-database-sql-547/#comments Thu, 18 Mar 2010 02:41:17 +0000 阿超 http://javadou.com/?p=547 数据库的几种分页介绍

建立表：

CREATE TABLE [TestTable] (
 [ID] [int] IDENTITY (1, 1) NOT NULL ,
 [FirstName] [nvarchar] (100) COLLATE Chinese_PRC_CI_AS NULL ,
 [LastName] [nvarchar] (100) COLLATE Chinese_PRC_CI_AS NULL ,
 [Country] [nvarchar] (50) COLLATE Chinese_PRC_CI_AS NULL ,
 [Note] [nvarchar] (2000) COLLATE Chinese_PRC_CI_AS NULL
) ON [PRIMARY]
GO

插入数据：(2万条，用更多的数据测试会明显一些)

SET IDENTITY_INSERT TestTable ON

declare @i int
set @i=1
while @i<=20000
begin
    insert into TestTable([id], FirstName, LastName, Country,Note) values(@i, 'FirstName_XXX','LastName_XXX','Country_XXX','Note_XXX')
    set @i=@i+1
end

SET IDENTITY_INSERT TestTable OFF

————————————-

分页方案一：(利用Not In和SELECT TOP分页)

语句形式：

SELECT TOP 10 *
FROM TestTable
WHERE (ID NOT IN
          (SELECT TOP 20 id
         FROM TestTable
         ORDER BY id))
ORDER BY ID

SELECT TOP 页大小 *

FROM TestTable

WHERE (ID NOT IN

(SELECT TOP 页大小*页数 id

FROM 表

ORDER BY id))

ORDER BY ID

————————————-

分页方案二：(利用ID大于多少和SELECT TOP分页）

语句形式：

SELECT TOP 10 *
FROM TestTable
WHERE (ID >
          (SELECT MAX(id)
         FROM (SELECT TOP 20 id
                 FROM TestTable
                 ORDER BY id) AS T))
ORDER BY ID

SELECT TOP 页大小 *

FROM TestTable

WHERE (ID >

(SELECT MAX(id)

FROM (SELECT TOP 页大小*页数 id

FROM 表

ORDER BY id) AS T))

ORDER BY ID

————————————-

分页方案三：(利用SQL的游标存储过程分页)

create  procedure XiaoZhengGe
@sqlstr nvarchar(4000), --查询字符串
@currentpage int, --第N页
@pagesize int --每页行数
as
set nocount on
declare @P1 int, --P1是游标的id
 @rowcount int
exec sp_cursoropen @P1 output,@sqlstr,@scrollopt=1,@ccopt=1,@rowcount=@rowcount output
select ceiling(1.0*@rowcount/@pagesize) as 总页数--,@rowcount as 总行数,@currentpage as 当前页
set @currentpage=(@currentpage-1)*@pagesize+1
exec sp_cursorfetch @P1,16,@currentpage,@pagesize
exec sp_cursorclose @P1
set nocount off

其它的方案：如果没有主键，可以用临时表，也可以用方案三做，但是效率会低。

建议优化的时候，加上主键和索引，查询效率会提高。

通过SQL 查询分析器，显示比较：我的结论是:

分页方案二：(利用ID大于多少和SELECT TOP分页）效率最高，需要拼接SQL语句

分页方案一：(利用Not In和SELECT TOP分页)   效率次之，需要拼接SQL语句

分页方案三：(利用SQL的游标存储过程分页)    效率最差，但是最为通用

在实际情况中，要具体分析。

—————————————————————————————————————————-

以上部分是转载!以上部分是转载!以上部分是转载!以上部分是转载!以上部分是转载!

以下简单说明一下几个API 服务器游标

declare @P1 int  --游标号码
declare @P2 int
set @P2=8  --参数[传入参数](可能是游标类型)
declare @P3 int
set @P3=1  --参数[传入参数](可能是游标锁类型)
declare @P4 int  --返回行数
begin
exec sp_cursoropen @P1 output,
 N'select * from authors',
 @P2 output,
 @P3 output,
 @P4 output

exec sp_cursorfetch @P1, 16, 1, 1
--exec sp_cursorfetch @P1, 16, 第几条开始, 多少条数据
exec sp_cursorclose @P1
end

现在还有一种，那就是利用SQL SERVER 2005新特性–分页存储过程

其核心是利用row_no

create PROCEDURE [dbo].[PR_Paging_RowNum]
(
@object varchar(3000),      --对哪个表和视图进行排序如table1
@sort varchar(3000) = NULL,    --要排序的字段 如 order by id desc
@Pageidx int = 1,
@PageSize int = 20,
@getfields varchar(5000) = '*',--如id,createtime,title.....
@getfields1 varchar(5000) = '*',-getfileds和getfields1一般情况下都是一样的，用来解决多表连接导致的select语法错误
@filter varchar(5000) = NULL--如where createtime>=2007-5-1 0:0:00
)
AS
declare @strsql varchar(5000)
set @strsql='declare @total int '+'select @total=count(*) from '+@object+@filter
if @pageidx=1
   set @strsql=@strsql+' select top '+cast(@pagesize as varchar(10))+' '+@getfields+',@total as totalrecords from '+@object+' '+@filter+@sort
else
begin
   declare @startrowno varchar(10)
   declare @endrowno varchar(10)
   set @startrowno=cast((@pageidx-1)*@pagesize+1 as varchar(10))
   set @endrowno=cast(@pageidx*@pagesize as varchar(10))
   set @strsql=@strsql+';with t0110x as ('+
   'select ROW_NUMBER() OVER('+@sort+') AS rowno,'+@getfields+',@total as totalrecords from '+@object+@filter+
   ')   '+
   'select '+@getfields1+',totalrecords from t0110x where rowno between '+@startrowno+' and '+@endrowno
end
exec( @strsql)
]]> http://javadou.com/page-database-sql-547/feed/ 0 url中的jsessionid解释- - http://javadou.com/url-jsessionid-why-548/ http://javadou.com/url-jsessionid-why-548/#comments Wed, 17 Mar 2010 02:39:30 +0000 阿超 http://javadou.com/?p=548 url中的jsessionid解释- -

（1）

这是一个保险措施

因为Session默认是需要Cookie支持的

但有些客户浏览器是关闭Cookie的

这个时候就需要在URL中指定服务器上的session标识

（2）

链接1：wapbrowse.jsp?curAlbumID=9 ；

链接2:wapbrowse.jsp;jsessionid=5AC6268DD8D4D5D1FDF5D41E9F2FD960?curAlbumID=9；

这两个链接是从模拟器运行时生成的source中拷贝过来的，两个链接都是指向wapbrowse.jsp,链接1由于不包含jsessionid,所以在 wapbrowse.jsp中变量为null,通过链接2打开wapbrowse.jsp可以正常访问session 变量

（3）

URL重写功能,为了防止一些用户把Cookie禁止而无法使用session而设置的功能.jsessionid后面的一长串就是你服务器上的session的ID号,这样无需cookie也可以使用session.

（4）

http本身是无session的，无法跟踪客户端的信息，换句话说：http协议不管是谁联接自己。

为了实现session，必须有浏览器支持。浏览器可以用cookie存储session，这是最通用的做法。

但是，如果我自己写一个完全符合http协议的浏览器，但是不配合服务器的session要求，那么服务器就无法产生session。

好在现在的浏览器都支持session要求，即使关闭了cookie，浏览器也会向服务器传递sessionid，这个id是存储在浏览器的内存空间中的，不保存在硬盘cookie中。

（5）

sessionid是作为一个临时cookie放在浏览器端的。

session的具体信息放在服务器端。

每次浏览器发出的请求，都会在http header里 带上 sessionid来标识自己。

既然用Struts，顺便再把JSTL用上，

下面一个非常有用的标签：

清单 12. 操作的语法

var=”name” scope=”scope”>

…

URL 重写是由 操作自动执行的。如果 JSP 容器检测到一个存储用户当前会话标识的 cookie，那么就不必进行重写。但是，如果不存在这样的 cookie，那么 生成的所有 URL 都会被重写以编码会话标识。注：如果在随后的请求中存在适当的 cookie，那么 将停止重写 URL 以包含该标识。

参考：http://www-900.ibm.com/developerWorks/cn/java/j-jstl0318/index.shtml

（6）

方法一：url中紧跟servlet/jsp文件名加;jsessionid=sessionId，其中sessionId由HttpSession.getId()得到，如http://localhost:8080/aaa/bbb.jsp;jsessionid=saldjfsdflsaeir234?para=1¶2=2

方法二：在application(ServletContext)里保存一个session管理器HashMap:sessionId—sessionRef，这样可以在所有的servlet/jsp里调用，这需要在url里将sessionId以参数形式传递，如http://localhost:8080/aaa/bbb.jsp?sessionId=saldjfsdflsaeir234?para=1¶2=2，在服务器端用request.getParameter(“sessionId”)获取

（7）

session是在服务器端保存。服务器根据url请求中的session_id来查找对应的session。

以一个bbs为例，网站需要根据每个请求url获取用户的信息，如果以cookie方式，用户信息全部是存放在cookie中的，这样可能会不安全；如果以 session方式，用户信息可以存放在服务器端，服务器只要从http请求中得到session_id，就可以得到存放在session中的用户信息了，这样安全性比较高。session在服务器中的表现方式依服务器而定，可能是写到临时文件中，也可能直接放在内存中。

服务器从http 请求中得到session_id的方式有两种：cookie和url重写。如果客户端启用cookie，那么session_id可以保存在cookie 中；如果禁用cookie，就用url重写方式，在url中添加.jsessionid=xxxxx参数部分，服务器会试图从url中得到. jsessionid参数作为session_id.

（8）

cookie 是保存在客户端的文本格式数据，session是客户端登录到应用，由服务器为该客户端建立的唯一的标识，可以在session里面保存该客户端的数据比如说用户帐号。

一般cookie可以用来保存你的登录帐号和密码，在你登录到应用服务上，自动添加到登录界面或直接发送到服务器上进行登录，这就是你经常能在论坛上看到的你的登录信息保存一年的选项 的实现方式

（9）

在http的报文格式里面cookie和session是在同一个包文位置上的

如果ie发现包文里面包含cookie/session的信息的话，他会根据安全级别来决定是否保存相关信息，比如，如果安全机制允许使用cookie那么 ie将把cookie的信息保存到临时文件里面，每次在请求服务器文件的时候会把收到的session的信息加入到请求的报文里面，这就是session 保存信息的原理。如果安全机制不允许使用cookie的话，虽然ie收到了cookie和session的信息，那么cookie的信息不会被写入临时文件，当ie再次请求服务器文件的时候，也不会把收到的session的信息加入到请求报文里面，服务器就无法知道session的信息了。

]]> http://javadou.com/url-jsessionid-why-548/feed/ 1 eclipse一个项目中同时开发flex和j2ee的环境配置 http://javadou.com/eclipse-dev-flex-j2ee-545/ http://javadou.com/eclipse-dev-flex-j2ee-545/#comments Tue, 16 Mar 2010 02:35:13 +0000 阿超 http://javadou.com/?p=545 eclipse一个项目中同时开发flex和j2ee的环境配置

因为工作需要，学了一周flex今天开始研究与服务器通信，选择了免费的BlazeDS。由于之前做项目用的是eclipse europa，就把flex builder 3 plugin直接安装到原有的eclipse上了，这样再配置的时候客户端编程用的flex和服务器端的J2EE就能整合到一个工程下了，希望对于暂时由jsp变flex项目的人容易熟悉和调试开发环境。

相关软件及工具：

1. Eclipse europa

2. Flex builder 3 (SDK3.3)

3. Tomcat 5.5

4. JDK 1.5

5. Blazeds-turnkey-3.2

前4项的安装就不用介绍了，通过eclipse的performance把需要的server和jre及flex的环境参数都配置好就可以了。下面开始进入flex+j2ee同项目的搭配步骤。

一、创建Web项目 File->New->Project->Web->Dynamic Web Project, 工程名为blazeDSApp，下一步指定服务器为tomcat5.5，下一步…均默认到结束，这样一个web工程创建好了。

二、解压缩Blazeds-turnkey-3.2，提取其中的blazeds.war，并解压到一个地方比如D:\blazeds, 并把blazeds.war也放在同一个目录下

三、<1>把D:\blazeds\WEB-INF下的flex文件夹复制到blazeDSApp工程的WebContent\WEB-INF下

<2>把D:\blazeds\WEB-INF下的lib文件夹复制到blazeDSApp工程的WebContent\WEB-INF下

到此，blazeDSApp工程的WebContent\WEB-INF下文件夹为flex、lib、classes

注：如果没有没有classes文件夹说明，java编译后的保存文件被放在工程下的build文件夹下了，可以通过修改WebContent下的.classpath中的output，如<classpathentry kind=”output” path=”WebContent/WEB-INF/classes” />

<3>把D:\blazeds\WEB-INF下的web.xml中的 <listener/> <servlet/> <servlet-mapping/>三个节点的内容复制到blazeDSApp工程的WebContent\WEB-INF下的web.xml中

这样当前的Web工程已经具有blazeds的功能了。

四、下面开始整合flex项目到web工程中。右键单击blazeDSApp工程，选择Flex Project Nature->Add Flex Project Nature

在弹出的对话框中设置相关参数。

对话框第一步中：Application server type 设置为J2EE 并勾选Use remote object access service 之LiveCycle Data Services

对话框第二步中：Flex WAR file 选择二中的D:\blazeds.war； 并把Output folder的路径改为WebContent

五、下面开始配置flex server。右键单击blazeDSApp工程，选择Properties

<1>首先选择Flex Build Path，在Library path的选项卡中，指定好flex sdk(就是flex builder3带的sdk，我用的是sdk3.3)的路径

<2>然后选择Flex Compiler， 指定Flex SDK version； 检查Additional compiler arguments里参数是否正确,如

-services “<工程路径>/blazeDSApp/WebContent/WEB-INF/flex/services-config.xml” -locale en_US

<3>最后选择Flex Server， RootURL设置为http://localhost:8080/blazeDSApp； Contenxt root设置为 blazeDSApp(工程名)

六、到此为止flex+j2ee同工程下共同开发的环境配置好了，现在检查下工程目录

* blazeDSApp

- flex_libs： 如果有第三方类库可以放在这里

- flex_src： flex源程序文件夹,如果使用cairngorm框架，这里可以具体再分为OV、event，business、delegate、view文件夹什么的

- html-template： flex应用程序模板

- src：java代码的源文件 格式就是包 包含 类文件

* WebContent

- history： 同html-template里的history

- META-INF：如果需要生成jar

* WEB-INF

* classes：存放编译后的java字节码

* flex： blazeds核心配置管理文件

* lib：blazeds相关的包

- web.xml：工程配置文件

- AC_OETags.js

- blazeDSApp.html

- blazeDSApp.swf

- playerProductInstall.swf

- .classpath

七、具体的HelloWorld程序就不描述了，比较简单都是一样的… 现在可以删除D:\blazeds和blazeds.war了，还有六中没提到的文件

八、添加tomcat服务器，检查进程中端口号是否冲突，不冲突则添加工程到服务器，运行服务器

浏览器中输入 http://localhost:8080/blazeDSApp/blazeDSApp.html 试试看吧

（完）

]]> http://javadou.com/eclipse-dev-flex-j2ee-545/feed/ 0 MyEclipse Initializing Java Tooling启动故障 MyEclipse http://javadou.com/myeclipse-initializing-java-tooling-544/ http://javadou.com/myeclipse-initializing-java-tooling-544/#comments Mon, 15 Mar 2010 02:05:25 +0000 阿超 http://javadou.com/?p=544 MyEclipse启动故障-Initializing Java Tooling
最近安装新系统后，重新安装了JDK，然后启动以前安装的MyEclipse8.0后，右下角提升“Initializing Java Tooling，进度1%”，而且长时间进度不变。

后来在网上找了一下，发现是由于JDK版本找不到造成的。

解决方法：
1、找到设置面板【Window】-》【Preferences】-》【Java】-》【Installed JREs】，删除不存在的JDK；

2、增加已安装的JDK；

3、重新配置Tomcat（或其他容器）地址，包括JDK；

4、将MyEclispe强行关闭，通过Windows任务管理器强行关闭。

5、重新启动MyEclipse，问题解决。

]]> http://javadou.com/myeclipse-initializing-java-tooling-544/feed/ 1 Java基础知识-Java获取操作系统信息 http://javadou.com/java-base-java-system-info-543/ http://javadou.com/java-base-java-system-info-543/#comments Sat, 13 Mar 2010 09:57:32 +0000 阿超 http://javadou.com/?p=543 Java基础知识-Java获取操作系统信息 调用方式如下：
Properties props=System.getProperties(); //获得系统属性集
String osName = props.getProperty(“os.name”); //操作系统名称
String osArch = props.getProperty(“os.arch”); //操作系统构架
String osVersion = props.getProperty(“os.version”); //操作系统版本
String osName = System.getProperty(“os.name”); //操作系统名称
String osArch = System.getProperty(“os.arch”); //操作系统构架
String osVersion = System.getProperty(“os.version”); //操作系统版本

public static String getProperty(String key)

键 相关值的描述
java.version Java 运行时环境版本
java.vendor Java 运行时环境供应商
java.vendor.url Java 供应商的 URL
java.home Java 安装目录
java.vm.specification.version Java 虚拟机规范版本
java.vm.specification.vendor Java 虚拟机规范供应商
java.vm.specification.name Java 虚拟机规范名称
java.vm.version Java 虚拟机实现版本
java.vm.vendor Java 虚拟机实现供应商
java.vm.name Java 虚拟机实现名称
java.specification.version Java 运行时环境规范版本
java.specification.vendor Java 运行时环境规范供应商
java.specification.name Java 运行时环境规范名称
java.class.version Java 类格式版本号
java.class.path Java 类路径
java.library.path 加载库时搜索的路径列表
java.io.tmpdir 默认的临时文件路径
java.compiler 要使用的 JIT 编译器的名称
java.ext.dirs 一个或多个扩展目录的路径
os.name 操作系统的名称
os.arch 操作系统的架构
os.version 操作系统的版本
file.separator 文件分隔符（在 UNIX 系统中是“/”）
path.separator 路径分隔符（在 UNIX 系统中是“:”）
line.separator 行分隔符（在 UNIX 系统中是“/n”）
user.name 用户的账户名称
user.home 用户的主目录
user.dir 用户的当前工作目录
]]> http://javadou.com/java-base-java-system-info-543/feed/ 1 Ajax快速入门-以XML作为数据载体发送和接收图书信息 http://javadou.com/ajax-xml-request-response-book-info-538/ http://javadou.com/ajax-xml-request-response-book-info-538/#comments Fri, 12 Mar 2010 02:06:49 +0000 阿超 http://javadou.com/ajax%e5%bf%ab%e9%80%9f%e5%85%a5%e9%97%a8-%e4%bb%a5xml%e4%bd%9c%e4%b8%ba%e6%95%b0%e6%8d%ae%e8%bd%bd%e4%bd%93%e5%8f%91%e9%80%81%e5%92%8c%e6%8e%a5%e6%94%b6%e5%9b%be%e4%b9%a6%e4%bf%a1%e6%81%af-2-538/ 是从一本书上抄下来的 感觉实用记录下来

Ajax快速入门，以XML作为数据载体发送和接收图书信息。

1、创建XMLHttpRequest对象：xmlHttp；
2、以XML数据存储用户选择的图书（ID）；
3、发送异步请求（调用XMLHttpRequest对象的相关方法和设置属性）：
3.1、调用open()方法，设置请求方式（POST/GET/HEAD）和URL;
3.2、调用setRequestHeader()方法，设置请求的报头信息；
3.2、调用send()方法，向服务器发送请求；
3.4、设置onreadystatechange属性，设置回调函数名。
4、XmlBookServlet处理XML字符串并返回XML字符串
4.1、读取请求（request）中的XML字符窜；
BufferedReader reader = request.getReader();
while ((len = reader.read(buf)) != -1) {
xml.append(new String(buf, 0, len));
}
4.2、利用dom4j提供的基于事件的处理模型对XML文档进行解析
saxReader.addHandler()；
4.3、在解析的同时读取数据库中相应的信息（详细信息），并注入对象中；
eltBooks.add(eltBook);
4.4、将对象写入返回响应(response)中：
response.getWriter()
xmlWriter.write(eltBooks);
5、回调函数处理服务器返回结果：
5.1、检查“请求的状态”，4为响应已完成；
5.2、检查“服务器的HTTP状态码”，200为OK；
5.3、清除先前请求的结果，包括表头和内容；
5.4、解析服务器响应的XML数据，构建表头和内容。

孙鑫《Struts2 深入详解》笔记，第18章。

下载

描述 名字 大小 下载方法
本文完整的源代码 sx_ch18001.rar 35 KB HTTP
]]> http://javadou.com/ajax-xml-request-response-book-info-538/feed/ 2 Struts2遍历List时输出Index http://javadou.com/struts2-list-index-535/ http://javadou.com/struts2-list-index-535/#comments Thu, 11 Mar 2010 02:04:28 +0000 阿超 http://javadou.com/struts2%e9%81%8d%e5%8e%86list%e6%97%b6%e8%be%93%e5%87%baindex-535/ 在循环中我们常常需要索引值 很多朋友不知道如何在struts2中得到，在Struts2架构中，输出列表时如果我们相同时输出该记录的index，只需在迭代器中定义status=”idx”，然后就可以使用idx.index取值了。
<!– 遍历结果集 begin –> <s:iterator value=”rentRefList” status=”idx”> <tr height=”25″ align=”center” bgcolor=”white”> <td bgcolor=”#f7f9ff”> <s:property value=”#idx.index+1″ /> </td>

]]> http://javadou.com/struts2-list-index-535/feed/ 1 让Struts2+ExtJS支持多语言 http://javadou.com/struts2-extjs-more-language-536/ http://javadou.com/struts2-extjs-more-language-536/#comments Wed, 10 Mar 2010 02:04:28 +0000 阿超 http://javadou.com/%e8%ae%a9struts2extjs%e6%94%af%e6%8c%81%e5%a4%9a%e8%af%ad%e8%a8%80-536/ 其实很简单就是几行代码就可以了
secondform = new Ext.Panel({
id : ‘tab2′,
title : ‘<s:text name=”XXX”/>’,
)

说明：Struts2支持多语言非常方便，只要写好对应的资源文件就可以了。ExtJS的多语言很麻烦，和Struts2配合起来就非常好了。

]]> http://javadou.com/struts2-extjs-more-language-536/feed/ 0 在Eclipse/MyEclipse中通过代理使用SVN http://javadou.com/eclipse-and-myeclipse-svn-537/ http://javadou.com/eclipse-and-myeclipse-svn-537/#comments Tue, 09 Mar 2010 02:04:28 +0000 阿超 http://javadou.com/%e5%9c%a8eclipsemyeclipse%e4%b8%ad%e9%80%9a%e8%bf%87%e4%bb%a3%e7%90%86%e4%bd%bf%e7%94%a8svn-537/ 有时候我们会碰到需要设置代理，然后通过svn获取源代码，下面我们来看一下如何设置；
1、

找到 C:\Documents and Settings\your userName\Application Data\Subversion 这个目录下的servers文件，用任意一个文本编辑器打开，找到
类似于如下的文字：

[global]
# http-proxy-exceptions = *.exception.com, www.internal-site.org
#http-proxy-host = proxy2.some-domain-name.com
#http-proxy-port = 9000
# http-proxy-username = defaultusername

将

#http-proxy-host
#http-proxy-port

这两行前面的#号去掉，并将＝号右边的值分别改为你的代理服务器地址和端口号即可。

2、设置Eclipse/MyEclipse，确认SVN的客户端是SVNKit：

这样，就可以在Eclipse/MyEclipse中通过代理使用SVN了。

]]> http://javadou.com/eclipse-and-myeclipse-svn-537/feed/ 0 安装SQL Server2005遇到的几个问题 http://javadou.com/sql-server2005-523/ http://javadou.com/sql-server2005-523/#comments Sun, 07 Mar 2010 00:50:47 +0000 阿超 http://javadou.com/%e5%ae%89%e8%a3%85sql-server2005%e9%81%87%e5%88%b0%e7%9a%84%e5%87%a0%e4%b8%aa%e9%97%ae%e9%a2%98-523/ 原来有个项目是SQL Server2000，想移植到最新的2005中。手头得到的是一个2005企业版，安装的时候遇到了几个问题，现在一一列出来希望对大家有所帮助。

1. “系统兼容性”警告

在执行到系统检测那一步的时候有一个警告，提示是“系统兼容性错误”，因为是一个警告，当时也没有在意就继续安装了。但是安装的时候只有一个客户端可以选择，不能安装sql server服务。后来没办法，又重新回到刚才的警告，自己看了下“安装帮助”，原来企业版只能运行在win2k server和2003等系统上，不能运行在XP上。这一点跟之前的2000是类似的。所以本机只能安装标准版的了。

2. 性能计数器要求安装错误

提示的对话框如下：

查看了联机帮助，提示下面的解决办法（这个方法我试了之后不是很好，另外一个方法见下面）：

1 在 Microsoft Windows 2003 或 Windows XP 桌面上，依次单击“开始”、“运行”，然后在“打开”中键入 regedit.exe，再单击“确定”。在 Windows 2000 中，使用 regedt32.exe 启动注册表编辑器。

2 定位到以下注册表项：

[HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Perflib]

“Last Counter”=dword:00000ed4 (5276)

“LastHelp”=dword:00000ed5 (5277)

3 上一步的“Last Counter”值 (5276) 必须与以下注册表项中“Perflib\009”的“Counter”项的最大值匹配，并且上一步的“Last Help”值 (5277) 必须与以下注册表项中“Perflib\009”的“Help”项的最大值匹配。

[HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Perflib\009]

注意 009 是英文中的一个示例。“Last Counter”和“Last Help”值是由 Windows 动态分配的；这两个值会因计算机的不同而不同。

4 如有必要，可修改“\Perflib”项中的“Last Counter”和“Last Help”值的值：在右侧窗格中，右键单击“Last Counter”或“Last Help”，单击“修改”，再单击“Base = “Decimal””，在“值数据”中设置值，再单击“确定”。如有必要，对另一个项重复以上过程，然后关闭注册表编辑器。

5 再次运行 SQL Server 安装程序。

可是按照上面的方法还是无法解决问题，后来网上查了下，找到一个解决的办法（见下面的参考资料）。不过其实没有作者介绍的那么复杂，只要在[HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Perflib] 找到04项下Count和Help中最大的项值（一般是最后一项）修改到Perflib目录下对应的“Laster Counter”项和“Laster Help”项就可以了。

3. SQL Server2005与SQL Server2000或SQL Server7.0共存的方法

因为都是在本机，安装2005的时候原来的SQL Server2000也不想删除，查了下资料这样是可以的，需要注意以下两点：

1) 在安装SQL2005的时候不要使用默认实例名称(SQL Server2000的实例名称是MSSQLSERVER)，手工输入一个自定义的不同于MSSQLSERVER的实例名称；

2) 如果和SQL Server2000安装到同一目录(例如C:\Program Files\Microsoft SQL Server)，那么在安装时不要选择安装SQL Server Management Studio，而是在安装之后到光盘的Tools\Setup目录下，运行SqlRun_Tools.msi安装。如果不小心已经安装上的话，在“添加/删除”里面删除掉SQL Server Management Studio然后在到光盘的Tools\Setup目录下，运行SqlRun_Tools.msi重新安装就可以了。

参考资料：

安装Ms SQL Server 2005 开发版时出现性能计数器要求安装错误的解决办法

http://submaie.cnblogs.com/archive/2006/02/07/326538.html

SQL Server2005与2000能否装在同一个系统？求确切答案

http://www.readbook8.com/dev/5701/4402802.htm

]]> http://javadou.com/sql-server2005-523/feed/ 0 乱码造成本站之前数据破坏，借此谈谈MySQL的乱码问题 http://javadou.com/mysql-luan-ma-532/ http://javadou.com/mysql-luan-ma-532/#comments Sat, 06 Mar 2010 00:50:48 +0000 阿超 http://javadou.com/%e4%b9%b1%e7%a0%81%e9%80%a0%e6%88%90%e6%9c%ac%e7%ab%99%e4%b9%8b%e5%89%8d%e6%95%b0%e6%8d%ae%e7%a0%b4%e5%9d%8f%ef%bc%8c%e5%80%9f%e6%ad%a4%e8%b0%88%e8%b0%88mysql%e7%9a%84%e4%b9%b1%e7%a0%81%e9%97%ae-532/ 为了防止升级失败我特意用sqlYog将数据备份了一下，然后升级的过程中没有任何问题，因为我发现原来的栏目排列有些改变，于是就直接清空数据然后再导入备份过的数据重新安装一下系统。当前清空数据库的时候没有多想，反正之前有备份。这个时候问题出现了：导入备份后的数据全部变成了乱码！确切的应该说是错码才对，因为出现的不是问号而是一些错误的中文字。

乱码

反复试了很多种方法依然是无效，后来从sqlYog官方网站上查到sqlYog从6.0开始每次生成的sql文件编码都是utf-8格式的，另外在操作数据之前都使用

  1. set names “utf8“;

将所有的环境都设置为utf8编码，你可以在sqlYog的查询窗口中使用

  1. SHOW VARIABLES LIKE ‘character_set_%‘;

查看一下语言环境。sqlYog在查看数据的时候首先查看原来数据库设置的编码格式，然后将其转换为utf8格式的数据，最后输出出来；如果修改数据则相反。上次我在博文中提到使用sqlYog6.03可以直接查看gbk编码的数据，但是查看utf8格式的编码是乱码，我觉得这应该是sqlYog6.03版本中转换编码算法的一个bug，果然在最新发布的6.10rc版本中就修复了这个错误；另外一个就是根数据库默认设置的编码也有很大的关系，因为MySQL使用的默认编码是latin1，正是这样一个非常具有历史原因的设置成为了造成乱码的最直接的原因。这里可能有人会说不是sqlYog操作之前都已经将环境设置为utf8格式了吗？这个时候应该跟MySQL本身的编码没有任何关系了呀。sqlYog操作的时候是不会有关系，但是其他进程(比如php、java等)操作的时候呢？数据写入的时候已经出现乱码了，问题就出在这里。所以为了完全杜绝MySQL的乱码问题，建议将MySQL的默认编码设置为utf8格式。

因为wordpress数据库中的编码都是utf8格式的，我又使用的sqlYog6.03版本，所以无论查看还是备份utf8的数据都是乱码。最后只能是逐一从百度快照中将数据找出来添加到数据库中，因为我在wordpress中设置的remark规则跟时间和最后的数据id号有关系，为了不至于造成在百度中搜索出来的结果失效，所以首先先将原来数据库中的这些数据导入到新的数据中。当然这个时候wordpress已经升级成2.3了，呵呵(苦笑中…)

目前在2006年8月份之前的数据还没有恢复，将近有80条。我会在最近这段时间将他升级完成的。

参考资料：Which MySQL Character Sets are supported by SQLyog?

]]> http://javadou.com/mysql-luan-ma-532/feed/ 0 phpMyAdmin初次安装拒绝登录的问题及解决方法 http://javadou.com/phpmyadmin-refuse-resolvent-531/ http://javadou.com/phpmyadmin-refuse-resolvent-531/#comments Fri, 05 Mar 2010 00:50:48 +0000 阿超 http://javadou.com/phpmyadmin%e5%88%9d%e6%ac%a1%e5%ae%89%e8%a3%85%e6%8b%92%e7%bb%9d%e7%99%bb%e5%bd%95%e7%9a%84%e9%97%ae%e9%a2%98%e5%8f%8a%e8%a7%a3%e5%86%b3%e6%96%b9%e6%b3%95-531/ 今天安装phpMyAdmin 2.10的时候修改认证方式为cookie之后进入程序首页登录的时候一直提示访问被拒绝，真的是奇怪了。后来从网上查了一下原来是需要清空一下浏览器缓存。

参考资料：hpMyAdmin 2.10.2 配置

]]> http://javadou.com/phpmyadmin-refuse-resolvent-531/feed/ 0 SQLyog 6.x 开始支持Unicode编码了！！ http://javadou.com/sqlyog-6-x-unicode-530/ http://javadou.com/sqlyog-6-x-unicode-530/#comments Thu, 04 Mar 2010 00:50:48 +0000 阿超 http://javadou.com/sqlyog-6-x-%e5%bc%80%e5%a7%8b%e6%94%af%e6%8c%81unicode%e7%bc%96%e7%a0%81%e4%ba%86%ef%bc%81%ef%bc%81-530/ sqlyog_box.jpg

一直是使用SQLyog来管理MySQL的，感觉他功能非常的强大，而且使用操作的时候非常的方便。但是一直以来SQLyog有个特别不爽的地方就是不支持Unicode，在查看数据库中的中文时会显示乱码，so如果直接用软件编辑保存的话显示到网页上面就是乱码了，完全没有使用SQL Server管理器那样的方便。

不过现在好了，今天无意间到SQLyog官方网站上面的时候，发现软件已经升级到6.x版本了，我所期待的支持中文的功能也实现了，爽啊~~~

]]> http://javadou.com/sqlyog-6-x-unicode-530/feed/ 0 Windows下安装zip包版本的MySQL http://javadou.com/windows-zip-mysql-529/ http://javadou.com/windows-zip-mysql-529/#comments Wed, 03 Mar 2010 00:50:48 +0000 阿超 http://javadou.com/windows%e4%b8%8b%e5%ae%89%e8%a3%85zip%e5%8c%85%e7%89%88%e6%9c%ac%e7%9a%84mysql-529/ 虽然官方提供了非常好的安装文件，但是有的时候不想每次再重装系统之后都要安装一遍MySQL，需要使用zip包版本的MySQL。在配置的时候有以下几个问题需要了解的，总结一下：

1. 设置MySQL为Windows服务

在Windows下用mysqld-nt.exe可以注册为服务，即用mysqld-nt –install mysql
这会设置为mysqld-nt.exe为mysql服务，相关信息在命令行模式下查询mysqld-nt –verbose –help

2. 启动服务时出现“错误1067”的解决方法

参考手册中明确说明了这个问题：

These messages often occur when the MySQL base or data directories are installed in different locations than the default locations (C:\Program Files\MySQL\MySQL Server 5.0 and C:\Program Files\MySQL\MySQL Server 5.0\data, respectively).

上面的意思是在没有将MySQL安装到默认的目录下面的情况下启动Windows服务的时候就会出现上述提示，解决的办法就是指定MySQL跟目录以及数据库目录。在my.ini文件最后增加以下内容，然后将my.ini拷贝到windows目录下。

  1. [mysqld]
  2. # set basedir to your installation path
  3. basedir=E:/mysql
  4. # set datadir to the location of your data directory
  5. datadir=D:/MySQLdata

3. 初始帐号

用户名root，密码为空，所以说默认情况下的MySQL5是不安全的。进入之后立即修改root帐号密码，命令如下：

  1. set password for root@localhost =password(‘yourPassword‘);
  2. flush privileges;
]]> http://javadou.com/windows-zip-mysql-529/feed/ 0 迟到的报道－ SQLServer2005 JDBC v1.1正式版发布 http://javadou.com/sqlserver2005-jdbc-v1-1-528/ http://javadou.com/sqlserver2005-jdbc-v1-1-528/#comments Tue, 02 Mar 2010 00:50:48 +0000 阿超 http://javadou.com/%e8%bf%9f%e5%88%b0%e7%9a%84%e6%8a%a5%e9%81%93%ef%bc%8d-sqlserver2005-jdbc-v1-1%e6%ad%a3%e5%bc%8f%e7%89%88%e5%8f%91%e5%b8%83-528/ 好久没有上SQL Server JDBC网站，原来早在8月29日就更新驱动了，现在是1.1的正式版。从其中一个开发者的博客上看到了更新的内容：

1. Integrated security 增强了安全连接，不过这个功能只支持 Windows 系统。我记得是需要拷贝一个dll文件

2. Client Failover, Database Mirroring support 支持 客户端失效倍援和数据库镜像功能
数据镜像功能其实是SQL Server2005的一个新功能，现在的JDBC驱动也支持了。关于这个功能更多可参考：http://www.microsoft.com/technet/prodtechnol/sql/2005/dbmirror.mspx
客户端失效倍援（不知道这个翻译是否准确）的描述是这样的：When connecting to a Sql Server 2005 Database that has a failover partner the JDBC v1.1 driver will cache failover information and retry to the failover partner on primary failure. Additionally you can use the new “failoverPartner” connection string keyword to handle initial connection failure scenarios.

3. 修复了以下上个版本里面的比较严重的bug（前面的数字是提交bug时候产生的序号，没有具体的含义）
<blockquote> <li>426389 Calling Statement.execute no longer causes an SQLException with the

message “sp_cursoropen/sp_cursorprepare: The statement parameter can

only be a single select or a single stored procedure‿ for UPDATE

WHERE queries when the selectMethod=cursor connection property is set.</li>

<li>436718 Calling PreparedStatement.execute no longer causes an SQLException

with the message “sp_cursoropen/sp_cursorprepare: The statement

parameter can only be a batch or a stored procedure with a single

select, without FOR BROWSE, COMPUTE BY, or variable assignments‿ for

INSERT INTO queries when the selectMethod=cursor connection property is set.</li>
<li>450639 The driver no longer throws an SQLException with the message “Server

failed to resume the transaction, desc: 4600000001.‿ when configuring

SQL Server 2005 as the JBoss JMS message store.</li>
<li>435796 Executing SQL WRITETEXT statements no longer throws an SQLException

with the message “No TDS_RET_STATUS was found for the stored procedure

output parameters.‿</li>
<li>424295 DatabaseMetaData.getMaxConnections no longer throws an SQLException with

the message “The configuration option ‘user connections’ does not exist,

or it may be an advanced option‿ for SQL Server 2005 servers.</li>
<li>433394 Calling Statement.executeBatch after setting a BLOB value no longer throws

an SQLException with the message “The conversion from BLOB to BINARY is unsupported.‿</li>
<li>435448 The driver no longer throws an SQLException with the message

“com.microsoft.sqlserver.jdbc.SQLServerException: Incorrect syntax near ‘-’‿

when sending a BigDecimal prepared statement parameter value to the server

with the 5.0 JRE.</li></blockquote>
参考资料：
JDBC 2005 v1.1 is now available.

]]> http://javadou.com/sqlserver2005-jdbc-v1-1-528/feed/ 0 怎样在SQL Server2005中删除数据库用户 http://javadou.com/sql-server2005-delete-user-527/ http://javadou.com/sql-server2005-delete-user-527/#comments Mon, 01 Mar 2010 00:50:48 +0000 阿超 http://javadou.com/%e6%80%8e%e6%a0%b7%e5%9c%a8sql-server2005%e4%b8%ad%e5%88%a0%e9%99%a4%e6%95%b0%e6%8d%ae%e5%ba%93%e7%94%a8%e6%88%b7-527/ 以前在SQL Server2000中删除数据库用户很简单，只要直接删除或者使用Drop User命令就可以了，但是SQL Server2005中直接操作是不行的，这是因为在SQL Server 2005中架构是做为实体对待的。所以要删除该用户，需要先删除该用户所拥有的架构或更改此架构的所有者。否则会提示”数据库主体在该数据库中拥有架构，无法删除。

另外，每一个数据库用户对应于一个系统登陆帐号，并且每一个架构只能赋予一个用户。所以直接删除用户的架构是不可以的，可以这样：首先创建一个新的登陆名，然后将需要删除的架构赋予这个新用户。这样就可以删除之前的用户了。

参考资料：
SQL 2005 应用手记
http://silverfox.mynew.ws/blog/index.php?/archives/111-SQL-2005.html

]]> http://javadou.com/sql-server2005-delete-user-527/feed/ 0 MS SQL Server 中事务日志变大的处理 http://javadou.com/ms-sql-server-log-deal-526/ http://javadou.com/ms-sql-server-log-deal-526/#comments Sun, 28 Feb 2010 00:50:48 +0000 阿超 http://javadou.com/ms-sql-server-%e4%b8%ad%e4%ba%8b%e5%8a%a1%e6%97%a5%e5%bf%97%e5%8f%98%e5%a4%a7%e7%9a%84%e5%a4%84%e7%90%86-526/ 在SQL Server中经常遇到事务日志变大的情况，除了将数据库设置为“自动收缩”外，还可以使用下面的SQL命令进行快速清除数据库中的事务日志，命令如下：

  1. – 第一步：清空日志
  2. DUMP TRANSACTION databasename WITH NO_LOG
  3. – 第二步：截断事务日志
  4. BACKUP LOG databasename WITH NO_LOG
  5. – 第三步：收缩数据库
  6. DBCC SHRINKDATABASE(databasename)

需要说明几点：
1. 上面的SQL命令需要按照顺序执行；
2. 执行上面的命令通常比直接使用右键菜单中的“收缩”命令要快很多

参考资料：
SQL SERVER 数据库日志已满，如何收缩数据库日志
http://blog.csdn.net/faintbear/archive/2005/02/06/283316.aspx
如何收缩数据库日志
http://www.cndiy8.com/data/web5701/20050228/20050228__3794589.html

]]> http://javadou.com/ms-sql-server-log-deal-526/feed/ 0 微软官方发布SQLServer JDBC 1.1 CTP版本 http://javadou.com/sqlserver-jdbc-1-1-ctp-524/ http://javadou.com/sqlserver-jdbc-1-1-ctp-524/#comments Fri, 26 Feb 2010 00:50:48 +0000 阿超 http://javadou.com/%e5%be%ae%e8%bd%af%e5%ae%98%e6%96%b9%e5%8f%91%e5%b8%83sqlserver-jdbc-1-1-ctp%e7%89%88%e6%9c%ac-524/ 经过漫长的6个月的等待，微软官方终于发布了SQL Server JDBC 1.1版本的驱动，不过该版本为CTP(Community Technology Preview) 社区预览版，主要修改了所有已知的bug。
这里引用SQL Server JDBC项目一名开发人员 Angel 的一段说明：

Announcing the June 2006 Community Tech Preview of the JDBC 2005 driver:
http://www.microsoft.com/downloads/details.aspx?familyid=f914793a-6fb…

This preview contains all the changes of CTP 1 including Integrated
Security, it includes rollup fixes for all the QFEs we have shipped to date
and we have addressed most customer issues filed through the product
feedback center.

To round it off we have also added a brand new feature: Client Failover. As
far as I know this is the first JDBC driver to take advantage of Sql Server
2005 Database Mirroring. This feature has been fully documented for this
CTP, we could really use feedback on both the functionality and the docs.

For a complete change list take a look at the release.txt file that ships
with the package, for the first time we are providing comprehensive
information on the work we have done since v1.0, let us know if this is
helpful information.

下载地址：http://msdn.microsoft.com/data/ref/jdbc/

]]> http://javadou.com/sqlserver-jdbc-1-1-ctp-524/feed/ 0 jQuery使用文档 jQuery 1.4.1 中文文档 CHM 版发布 http://javadou.com/jquery-1-4-1-chm-512/ http://javadou.com/jquery-1-4-1-chm-512/#comments Sun, 21 Feb 2010 08:45:06 +0000 阿超 http://javadou.com/?p=512 新鲜出炉，更新了大量内容，应该还有一些BUG，欢迎纠错：

http://code.google.com/p/jquery-api-zh-cn/downloads/list

本来更早出来的，结果半路又杀出1.4.1，而且发现bind、live还有ajax等方法有大量更新，所以重新翻译这三个方法，消耗了大把时间。所以今天才发出来。

还有个html版的http://jquery-api-zh-cn.googlecode.com/svn/trunk/index.html

似乎这个不怎么更新了 大家还是用chm的吧 也比较方便

]]> http://javadou.com/jquery-1-4-1-chm-512/feed/ 0 xfire学习webservice–基于xfire的web service搭建 http://javadou.com/xfire-webservice-xfireweb-service-511/ http://javadou.com/xfire-webservice-xfireweb-service-511/#comments Sat, 13 Feb 2010 07:11:53 +0000 阿超 http://javadou.com/?p=511 标题：基于xfire的web service搭建
出处：小强的家
时间：Sun, 12 Apr 2009 12:30:29 +0000
作者：xiaojiit
地址：www.sharejava.cn/blog/read.php/12.htm

内容：
这里，用的xfire1.2.6和Spring 2.0，开发工具用的MyEclispe，虽然MyEclipse自带了开发xfire的插件，但为了不依赖开发工具，所以以下为手动创建。
Xfire 可以很好的和Spring 集成，下面分两部分介绍
纯Xfire 的web service
1.1、先建一个web 项目，打开下载到的xfire包，将lib下的所有 Jar包和modules目录下的所有Jar包拷到web 项目的WEB-INF/lib目录下。
1.2、修改web.xml文件，添加如下内容，以支持xfire：

<servlet>
<servlet-name>XFireServlet</servlet-name>
<servlet-class>org.codehaus.xfire.transport.http.XFireConfigurableServlet
</servlet-class>
<load-on-startup>0</load-on-startup>
</servlet>
<servlet-mapping>
<servlet-name>XFireServlet</servlet-name>
<url-pattern>/services/*</url-pattern>
</servlet-mapping>

这样，便可以通过http://localhost:8080/projectName/services/ 路径来访问所有发布的web services了。
1.3、在项目下的WEB-INF目录下建立META-INF/xfire/这个目录，在此目录下建立services.xml文件，这个文件用来添写我的要发布的web services。文件内容如下所示：

<beans>
<service  xmlns=”http://xfire.codehaus.org/config/1.0″>
<name>HelloService</name>
<serviceClass>com.services.HelloService</serviceClass>  <implementationClass>com.services.HelloServiceImpl</implementationClass>
</service>
</beans>
文件的内容如下：
：发布一个web service；
：发布web service的名称；
：提供服务的接口类；
：实现服务接口类的具体类。

注：这里用的Spring 2.0，如果是用xfire 自带的Spring1.2.6，应该将  xmlns=”http://xfire.codehaus.org/config/1.0″ 放到里去定义。
1.4、下面，将这个web 项目，发布到tomcat下，便可以使用

http://localhost:8080/xfire/services/HelloService?wsdl

来调用这个web service了。
于Spring 集成的Xfire 开发web services，这里用的是spring 2.0，如果是spring2.5，需要将spring-webmvc.jar添加进来。

下面说与Spring 集成的Xfire开发步骤
Spring 与xfire 有三种结合方式，下面以直接与spring集成的方法说明。
（通过Spring的org.springframework.web.servlet.DispatcherServlet）。
2.1、将xfire与spring的JAR包放到web 项目的classPath
2.2、修改web.xml，使其支持Spring 与xfire，添加如下内容：

<context-param>
<param-name>contextConfigLocation</param-name>
<param-value>
/WEB-INF/conf/applicationContext.xml
classpath:org/codehaus/xfire/spring/xfire.xml
</param-value>
</context-param>
<listener>
<listener-class>
org.springframework.web.context.ContextLoaderListener
</listener-class>
</listener>
<servlet>
<servlet-name>xfire</servlet-name>
<servlet-class>
org.springframework.web.servlet.DispatcherServlet
</servlet-class>
<load-on-startup>0</load-on-startup>
</servlet>
<servlet-mapping>
<servlet-name>xfire</servlet-name>
<url-pattern>/service/*</url-pattern>
</servlet-mapping>

2.3、根据web.xml的内容，创建Spring的配置文件：applicationContext.xml
在本例中，将此文件放在WEB-INF/conf目录下。内容如下：

<?xml version=”1.0″ encoding=”UTF-8″?>
<!DOCTYPE beans PUBLIC “-//SPRING//DTD BEAN//EN” “http://www.springframework.org/dtd/spring-beans.dtd”>
<beans>
<bean id=”helloBean” />
</beans>

这里，定义了一个bean,这里用的是web services接口的实现类。
2.4、在WEB-INF下创建xfire-servlet.xml文件，这里的xfire是org.springframework.web.servlet.DispatcherServlet这个servlet的名称，应该根据自己的进行修改
内容如下：

<?xml version=”1.0″ encoding=”UTF-8″?>
<!DOCTYPE beans PUBLIC “-//SPRING//DTD BEAN//EN” “http://www.springframework.org/dtd/spring-beans.dtd”>
<beans>
<!– 在这写上这名，这样就可以用applicationContext.xml里定义的Bean –>
<import resource=”classpath:org/codehaus/xfire/spring/xfire.xml” />

<!– 这是定义URL映射 –>
<bean>
<property name=”urlMap”>
<map>
<!– 在这写每一个Web Service的URL映射 –>
<entry key=”/HelloService”> //URL，访问地址
<ref bean=”hello” />
</entry>
</map>
</property>
</bean>

<!– 定义一个基础Service,以下的Service引用它 –>
<bean id=”baseWebService”

lazy-init=”false” abstract=”true”>
<!– 引用xfire.xml中定义的工厂 –>
<property name=”serviceFactory” ref=”xfire.serviceFactory” />
<!– 引用xfire.xml中的xfire实例 xfire是web.xml配置的DispatcherServlet的名称–>
<property name=”xfire” ref=”xfire” />
</bean>

<!– 定义一个Hello　的WebService，这里的serviceClass是接口 –>
<bean id=”hello” parent=”baseWebService”>
<property name=”serviceBean”>
<ref bean=”helloBean” />
</property>
<property name=”serviceClass”>
<value>com.service.HelloService</value>
</property>
</bean>
</beans>

这样便生成一个web Service，可以通过域名来访问，并编写客户端代码了。

另一种方式，使用xfire自带的org.codehaus.xfire.spring.XFireSpringServlet这个类进行设置。
方法如下：
修改web.xml，添加如下内容：

<context-param>
<param-name>contextConfigLocation</param-name>
<param-value>/WEB-INF/applicationContext.xml</param-value>
</context-param>
<listener>
<listener-class>
org.springframework.web.context.ContextLoaderListener
</listener-class>
</listener>

<!–XFire 配置  –>
<servlet>
<servlet-name>XFireServlet</servlet-name>
<servlet-class>
org.codehaus.xfire.spring.XFireSpringServlet
</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>XFireServlet</servlet-name>
<url-pattern>/service/*</url-pattern>
</servlet-mapping>

这样，便不必使用xfire-servlet.xml文件，直接在applicationContext.xml里添加Web Service的Bean就可以了。applicationContext.xml代码如下：

<?xml version=”1.0″ encoding=”UTF-8″?>
<!DOCTYPE beans PUBLIC “-//SPRING//DTD BEAN//EN” “http://www.springframework.org/dtd/spring-beans.dtd”>
<beans>

<!– web service 配置 –>
<import resource=”classpath:org/codehaus/xfire/spring/xfire.xml” />

<bean id=”HelloServiceImpl”
/>

<bean id=”HelloService”
>
<property name=”xfire” ref=”xfire” />
<property name=”serviceBean” ref=”HelloServiceImpl” />
<!– WebService的实现类bean –>
<property name=”serviceClass”
value=”com.service.service.HelloService” />
</bean>
</beans>

但个Web Service是没有任何安全性可言的，任何拿到WSDL的人都可以轻松地构造客户端程序访问我们的Web Service服务。

]]> http://javadou.com/xfire-webservice-xfireweb-service-511/feed/ 0 如何使用xFire开发webService返回复杂对象List http://javadou.com/xfire-webservice-return-list-510/ http://javadou.com/xfire-webservice-return-list-510/#comments Fri, 12 Feb 2010 07:10:00 +0000 阿超 http://javadou.com/?p=510 XFire开发时，在返回数据类型时遇到了一些麻烦，查到这样一篇文单，非常不错，故收藏之。

翻译： zilong3927  原文地址： http://docs.codehaus.org/display/XFIRE/Mapping+collections

调用 Web Services 时，经常需要返回集合（ collection ）作为结果，或者接受 collection 型的参数。 SOAP 本身就支持这一点。

但是这一机制的问题在于， java 语言的 collections 是无类型的（ untyped ） . 因此，如果要在 Java 1.4 当中支持 collections ， 就需要做一些额外的工作。

Java 5 & 范型（ Generics ）

首先而且是推荐的做法是在 JDK5 当中使用范型（ generics ）。范型能够使你在代码当中为你的 collections 指定类型信息， 从而允许 xfire 自动地推导出 collection 类型，生成正确的 wsdl 等等。

下面示例了如何写这样的一个方法：

public    Collection <   String   >  getValuesForIds(Collection <   Integer   > );

Java 1.4 & 集合（ Collections ）

有些情况下并不总能够使用范型（ generics ） . 例如，如果你的部署环境使用 JDK 1.4 ， 或者你想暴露一些遗留的服务，而同时又不打算修改任何代码也不打算进行移植。

对于这样的一些情况而言， 你需要生成一个 xml 映射文件，来指定方法和它们对应的集合类型（ collection types ） .

这个 xml 文件的名字必须是 <className>.aegis.xml ， 其中 className 是你的服务（ service ）的接口类（ unqualified class ）的名字。

下面最好通过一个例子来展示这个 xml 文件的格式。 我们想要展现的服务有这样的一个接口 :

public   interface  MyService1{
String getFoo();
Collection getCollection();
void  setList(  int  id ， java.util.List);
}

既然代码中的 collections 没有指定类型， 我们剧需要生成一个 xml 文件来指定所需要的类型。 这个文件的路径应该和 MyService1.class 在同一个包（ package ）当中， 并且它的名字应该是 MyService1.aegis.xml

对于这个接口来说，一个最简单的映射文件如下 :
< mappings >
< mapping >
< method  name = “getCollection”   >
< return-type  componentType = “java.lang.String”   />
</ method >
< method  name = “setList”   >
< parameter  index = “1″  componentType = “java.lang.String”   />
</ method >
</ mapping >
</ mappings >

注意这个映射文件确切地指定了所需要的信息，不包含任何冗余。 例如， getFoo 方法没有被指定，这是由于它没有包含任何 collections ，因此能够在没有任何映射信息的情况下暴露给使用者。

其次， setCollection 方法没有指定索引为 0 的参数。 这是由于该参数类型为 int ，因此不需要任何映射

如果我们有多个方法，都匹配指定的映射又该怎么办 ? 这种情况下， 映射就对所有匹配的方法均有效。

所以，如果在我们的接口中增加以下的方法：

void  setList( int id ，java.util.List， boolean persist);

那么现在我们的映射定义对于两个 setList 方法都有作用。这种情况下， 我们不必为额外的参数（译者注：此处指 boolean persist ）指定两次映射 . 映射文件就指定了所有那些第二个参数为 List 的方法，并假定 List 中包含的都是 strings 。

如果我们想让那个具有 3 个参数的方法，其中的 list 不包含 Strings ， 而是实际上包含 Dates? 这种情况下， 就需要一个更确切的映射来覆盖（ override ）原先那个更一般的， 所以我们的映射文件需要添加下面这个定义 :
< method  name =  “setList”    >
< parameter  index = “1″  componentType = “java.lang.String”   />
< parameter  index = “2″  class = “boolean”   />
</ method >

注意一下类型属性。 现在这个映射将对所有那些第二个参数为 List ，第三个参数为 boolean 型的方法适用。 在我们的接口当中，这个映射唯一地确定了一个特定的方法，使用这个映射就能够解释方法当中的 List 参数。

在优先顺序方面， 更确切的映射总是优先于更一般的。

让我们考虑下面这个复杂一些的例子 :

public      interface    MyService2
{
Collection getCollection();  // method 1
Collection getCollection(  int  id);  // method 2
Collection getCollection( String id);  // method 3
Collection getCollectionForValues(  int  value ， Collection c);  // method 4
Collection getCollectionForValues( String id ， Collection c);  // method 5
}

映射文件的内容为 :
< mappings >
< mapping >
<!–  mapping 1  –>
< method  name = “getCollection”   >
< return-type  componentType = “java.lang.Double”   />
</ method >
<!–  mapping 2  –>
< method  name = “getCollection”   >
< return-type  componentType = “java.lang.Float”   />
< parameter  index = “0″  class = “int”   />
</ method >
<!–  mapping 3  –>
< method  name = “getCollectionForValues”   >
< return-type  componentType = “java.math.BigDecimal”   />
</ method >
<!–  mapping 4  –>
< method  name = “getCollectionForValues”   >
< parameter  index = “0″  class = “java.lang.String”   />
< parameter  index = “1″  componentType = “java.util.Date”   />
</ method >
<!–  mapping 5  –>
< method  name = “getCollectionForValues”   >
< return-type  componentType = “java.util.Calendar”   />
< parameter  index = “0″  class = “int”   />
< parameter  index = “1″  componentType = “java.lang.Bit”   />
</ method >
</ mapping >
</ mappings >

这个文件的格式是不需要做过多解释的。但有几点还是需要加以说明。

先来看一下第一个映射 (mapping 1) 。 这个映射指定了所有 getCollection 方法所返回的 collections contain 均包含 java.lang.Doubles 。 如果没有指定其他的 getCollection 映射， 那么这个映射将对方法 1 ， 2 ， 3 都适用。

但是，第二个映射更加明确地指定了它所适用的方法。即如果 getCollection 方法的第一个参数是 int 型，那么该方法所返回的 collection 包含的是 Float 型。 由于这条规则更加明确，它将为方法 2 覆盖掉第一个映射，这是满足映射约束标准的。

使用以上的规则，不难推导出方法 4 和方法 5 返回的 collections 结果的组件类型（ component types ）。

Collections on Javabeans

对于使用 collections 的 java beans 来说，语法也是类似的。 例如，比方说我们有一个 Company bean ，包含了一个 List ， 其中的对象是 employees:

public   class  Company
{
private  Collection employees;
Collection getEmployees() {  return  employees; }
public   void  setEmployees(Collection employees) {  this  .employees  =  employees };
}

除了可以使用 <method> & <parameter> 元素外， 也可以使用 <property> 元素 :
< mappings >
< mapping >
< property  componentType = “org.codehaus.xfire.Employee”   />
</ mapping >
</ mappings >

Handling Maps

Java Maps 并不能很好地映射到 XML Schema (no pun intended) ，因为 XML Schema 中没有 Map 的概念，客户端也是这样， Maps 被转换成 {key ， value} 元组的集合。 除了要提供 value 的类型以外，你还必须为 Aegis 提供 key 的类型 :

public     class  GiftService {
Map getGiftList() {  /*  returns a map of NiceChild => Present  */  }
}

映射文件应该像下面这样 :
< mappings >
< mapping >
< method  name = “getGiftList”   >
< return-type  keyType = “org.codehaus.xfire.NiceChild”  componentType = “org.codehaus.xfire.Present”   >
</ method >
</ mapping >
</ mappings >

这将生成下面的类型 :
< xsd:complexType  name =  “NiceChild2PresentMap”    >
< xsd:sequence >
< xsd:element  name = “entry”  minOccurs = “0″  maxOccurs = “unbounded”   >
< xsd:complexType >
< xsd:sequence >
< xsd:element  name = “key”  type = “ns1:NiceChild”  minOccurs = “0″  maxOccurs = “1″   />
< xsd:element  name = “value”  type = “ns1:Present”  minOccurs = “0″  maxOccurs = “1″   />
</ xsd:sequence >
</ xsd:complexType >
</ xsd:element >
</ xsd:sequence >
</ xsd:complexType >

Collections of Collections of Collections of….

在某些情况下，你可能想要传递 Collections of Collections 。比方说你有一个返回 List of a List of Doubles 的服务 ( 不要问为什么你要做这样一件事情 …):

public   class  ListService
{
public  List getListOfListOfDoubles
{
List l  =   new  ArrayList();
List doubles  =   new  ArrayList();
doubles.add(  new  Double ( 1.0 ));
l.add(doubles);
return  l;
}
}

要处理这种情况，我们需要引进一个新的 <component> 元素。 下面是一个很好的例子 :
< mappings >
< mapping >
< method  name = “getListofListofDoubles”   >
< return-type  componentType = “#someDoubles”   />
</ method >
< component  name = “someDoubles”  class = “java.util.List”  componentType = “java.lang.Double”   />
</ mapping >
</ mappings >

正像你在这里所看到的，返回类型的 componentType 是一个指向 <component> 的引用，而不是一个类。组件类型 “#someDoubles” 引用到名字为 “someDoubles” 的 <component> 。

Aegis 将会自动给这些 collections 命名为 ArrayOfDouble 和 ArrayOfArrayOfDouble 。 你也可以改变这些名字。 要设置你自己的名字， 提供一个 “typeName” 属性即可 :
< mappings >
< mapping >
< method  name = “getListofListofDoubles”   >
< return-type  componentType = “#someDoubles”  typeName = “LotsOfDoubles”   />
</ method >
< component  name = “someDoubles”  class = “java.util.List”  typeName = “SomeDoubles”  componentType = “java.lang.Double”   />
</ mapping >
</ mappings >

]]> http://javadou.com/xfire-webservice-return-list-510/feed/ 0 webservice-XFire开发一个简单的web服务 http://javadou.com/webservice-xfire-develop-fires-demo-509/ http://javadou.com/webservice-xfire-develop-fires-demo-509/#comments Thu, 11 Feb 2010 07:04:28 +0000 阿超 http://javadou.com/?p=509 在这一节，你将了解到如何将一个普通的 java 文件转换为一个 web 服务， services.xml 文件是如何定义的，如何发布这个 web 服务、如何获得这个服务的 WSDL 、如何创建 Client 代码、如何测试这个 web 服务。
首先打开 Eclipse ，创建一个普通的 java 工程，将 xfire 所需的 jar 和 xfire 的 jar 加入到工程所需的类库引用中。创建一个简单的 java 文件，这个 java 文件简单到只提供一个 add 方法。

package com.kuaff.xfire.samples;
public class MathService
{
public long add( int p1, int p2)
{
return p1 + p2;
}
}

在 src 目录下创建 META-INF/xfire 目录，然后在 META-INF/xfire 目录下创建 services.xml 文件，文件内容为：
<beans xmlns=”http://xfire.codehaus.org/config/1.0″>
<service>
<name>MathService</name>
<namespace>http://www.kuaff.com/xfire/samples/MathService</namespace>
<serviceClass>com.kuaff.xfire.samples.MathService</serviceClass>
</service>
</beans>
这个文档定义了你要发布的 web 服务，这个定义了一个名为 MathService 的服务，服务类为 com.kuaff.xfire.samples.MathService 。
这样我们的一个简单的 web 服务就开发完成了，下面就要把它发布出去。
将工程 bin 目录下的所有的文件复制到第一节中配置的 tomcat/webapps/xfire/WEB-INF/classes 文件夹下，启动 tomcat ，你就可以检查这个 web 服务是否发布成功了。
打开浏览器，在浏览器地址栏中输入 http://localhost:8080/xfire/services/ ，正常情况下应该浏览器应该显示类似下面的页面。

Available Services:

  • MessageHistoryService [wsdl]

注意：请在浏览器中输入 http://localhost:8080/xfire/services/ 而不是 http://localhost:8080/xfire/services ，虽然两者显示的页面相同，但是点击页面上的链接，后者的链接会出错，因为后者后面少加了一个“ / ”。点击 [wsdl] 链接，可以查看这个 web 服务的 wsdl 文档。

如果在你的机器上的显示如上面所示，则说明你的这个 web 服务发布成功，可以正常提供基于 http 的 web 服务。

下面一个问题就是如何开发一个 Client ，来消费（使用）这个 web 服务。

XFire 、 Axis 、 asp.net 以及其它的一些商业产品都提供了根据 wsdl 文档创建客户端代码的工具。这里采用 Xfire 提供的 wsgen 工具来创建客户端的访问代码。

Wsgen 是 xfire 提供的一个 ant task ， task 的申明如下：

<taskdef name= “wsgen” classname= “org.codehaus.xfire.gen.WsGenTask” classpathref= “xfire 的 jar 路径 ” />

这样，就可以在 build.xml 文件中使用这个 task ：

<wsgen outputDirectory= “client” wsdl= “MathService.wsdl” package= “com.kuaff.xfire.samples” />

outputDirectory 属性定义创建的代码所在的文件夹， wsdl 是 web 服务的 wsdl 文件， package 代表创建的代码的 packege 。还可以通过 binding 属性制定 bind 类型： jaxb 或者是 xmlbeans ，

这样，就会在 client 文件夹下创建多个 java 文件，这些文件提供了访问 web 服务的方法。
在这里声明一点，创建的代码大量的使用了 java 注释，这个 JSE5 中提供的新特性，所以你需要使用 JSE5 编译， Eclipse 也必须要 3.1 以上的版本。
这段 ant 脚本将创建三个文件： MathServicePortType 、 MathServiceImpl 和 MathServiceClient 。 MathServicePortType 是这个 web 服务的客户端接口存根、 MathServiceImpl 实现了这个接口。 MathServiceClient 封装了访问这个 web 服务的方法。
最后，你可以创建一个单元测试类，用来测试这个客户端类。这个类的内容如下：
package com.kuaff.xfire.samples;
import junit.framework.TestCase;
public class MathServiceClientTest extends TestCase
{
public void testAdd()
{
MathServiceClient client = new MathServiceClient();
MathServicePortType ms = client.getMathServiceHttpPort();
long result = ms.add(10, 20);
assertEquals (result, 30);
}
}

]]> http://javadou.com/webservice-xfire-develop-fires-demo-509/feed/ 0 XFire开发webservice服务和客户端全攻略 http://javadou.com/xfire-webservice-service-client-507/ http://javadou.com/xfire-webservice-service-client-507/#comments Wed, 10 Feb 2010 07:01:31 +0000 阿超 http://javadou.com/?p=507 XFire 是与Axis 2并列的新一代Web Service框架，通过提供简单的API支持Web Service各项标准协议，帮助你方便快速地开发Web Service应用。

相 对于Axis来说，目前XFire相对受欢迎，加上其提供了和Spring集成的支持，在目前的Web Service开源社区拥有众多的追随者。并且因为XFire为Spring提供的支持，使得我们可以很容易在Spring中使用XFire构建Web Service应用。

XFire 与Axis2相比具有如下特征：

l         支持一系列Web Service的新标准–JSR181、WSDL2.0 、JAXB2、WS-Security等；

l         使用Stax解释XML,性能有了质的提高。XFire采用Woodstox 作Stax实现；

l         容易上手，可以方便快速地从pojo发布服务；

l         支持Spring、Pico、Plexus、Loom等容器；

l         灵活的Binding机制，包括默认的Aegis,xmlbeans,jaxb2,castor；

l         高性能的SOAP 栈设计；

l         支持Spring、Pico、Plexus、Loom等容器。

XFire 与Axis1性能的比较如下：

l         XFire 比Axis1.3快2-6倍；

l         XFire 的响应时间是Axis1.3的1/2到1/5。

XFire 在WebService框架中开始较晚，它从现有的框架中借鉴了许多优秀的理念，力争将Web Service的应用开发难度降到最低。此外，还提供了各种绑定技术、支持多种传输协议，对WebService体系中许多新的规范提供了支持。

下面让我们来看一个XFire于Spring集成的helloWorld的简单例子。

一．实现的功能和特点

本例具有如下功能和特点：

1）  基于J2EE平台的Web Service服务；

2）  开发方便，配置简单；

3）  与spring无缝集成。

XFire 是完全基于流数据处理进行工作的系统，这意味着XFire不是将整个SOAP文档缓存在内存中，而是以管道的方式接收SOAP流数据。这种工作方式的转变带来了可观的性能回报，同时节省了内存的占用。

XFire 从 管道中接收一个SOAP请求到返回一个SOAP响应，会经历一系列的阶段。在管道调用的任何一个阶段，XFire都可以添加一些额外的Handler，在 对消息进行加工处理后再传入到下一个阶段中。在SOAP请求消息对Web Service发起真正调用之前，分别会经过传输、预转发、转发、策略实施、用户信息处理、预调用、服务调用等阶段。

二．开发环境

笔者的开发环境描述如下：

1）  jdk: 1.5 版本；

2）  Tomcat ：5.5.20；

3）  MyEclipse: 5.1.1 GA 。

三．开发步骤

1. 工程与环境的建立

在 MyEclipse中新建Web工程，名为webservice_helloworld。选择该工程后，点击右键选择MyEclipse->Add Web Service Capabilities，弹出Add Web Service Capabilities对话框，点击“Next”，弹出Project Library Configuration对话框，默认选择Core Libraries，点击“Finish”按钮，完成XFire核心包的添加。为了后续的客户端的测试，还需读者加入commons- httpclient.jar包到WEB-INF/lib下。

部署后可看到此时WEB-INF/lib的jar包列表如下：

activation-1.1.jar 、 commons-beanutils-1.7.0.jar、commons-codec-1.3.jar、commons- httpclient.jar、commons-logging-1.0.4.jar、jaxen-1.1-beta-9.jar、jaxws-api- 2.0.jar、jdom-1.0.jar、jsr173_api-1.0.jar、mail-1.4.jar、saaj-api-1.3.jar、 saaj-impl-1.3.jar、spring-1.2.6.jar、stax-api-1.0.1.jar、wsdl4j-1.5.2.jar、 wstx-asl-3.0.1.jar、xbean-2.1.0.jar、xbean-spring-2.5.jar、xfire-aegis- 1.2.2.jar、xfire-annotations-1.2.2.jar、xfire-core-1.2.2.jar、xfire- java5-1.2.2.jar、xfire-jaxws-1.2.2.jar、xfire-jsr181-api-1.0-M1.jar、xfire- spring-1.2.2.jar、XmlSchema-1.1.jar

为了后续的开发和测试，在src目录下分别建立test和webservice目录，分别用于存放测试文件和webservice的相关类。

2 ．Web Service实现的编写

在本例中，我们只是做一个helloWorld的简单例子。Web Service服务端提供一个根据输入的名字信息回复相应的helloWorld信息的。例如，当名字为“阿蜜果”时，恢复信息为“hello，阿蜜果”。下面让我们一步一步来开始进行编码。

1） web.xml 的配置

一 般情况下，我们通过HTTP作为Web Service的传输协议，这样我们只需启动一个Web服务器(如Tomcat，在本例中使用的是Tomcat5.5.20)，这样客户端就可以通过 HTTP访问到Web Service服务。为了集成Spring容器，XFire专门提供一个XFireSpringServlet，我们可以在web.xml中配置该 Servlet，将Spring容器中定义的Web Service在某个URI下发布。

为了能正确使用XFire，需在web.xml中进行相应配置，在该文件中配置XFire的 servlet 和 servlet-mapping 。同时因为本实例需要将 XFire 集成到 Spring 中，因而需要在 web.xml 文件中加载 Spring 的相应配置文件。在本实例中，我们首先在 WEB-INF 下建立两个配置 Spring 配置文件，一个为 applicationContext.xml ，该文件用来定义本工程的 bean ，一个为 xfire-servlet.xml ，用来配置 XFire 的相关 bean 。修改后的 web.xml 的内容如下所示：
<? xml version=”1.0″ encoding=”UTF-8″ ?>
< web-app  xmlns =”http://java.sun.com/xml/ns/j2ee”  xmlns:xsi =”http://www.w3.org/2001/XMLSchema-instance”  version =”2.4″  xsi:schemaLocation =”http://java.sun.com/xml/ns/j2ee   http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd” >
< display-name > XFireService </ display-name >
<!–  begin Spring配置  –>
< context-param >
< param-name > contextConfigLocation </ param-name >
< param-value > /WEB-INF/applicationContext.xml,/WEB-INF/xfire-servlet.xml </ param-value >
</ context-param >
< listener >
< listener-class >  org.springframework.web.context.ContextLoaderListener
</ listener-class >
</ listener >
< listener >
< listener-class >      org.springframework.web.util.IntrospectorCleanupListener
</ listener-class >
</ listener >
<!–  end Spring配置  –>

<!–  begin XFire 配置  –>
< servlet >
< servlet-name > xfire </ servlet-name >
< servlet-class > org.springframework.web.servlet.DispatcherServlet </ servlet-class >
</ servlet >
< servlet-mapping >
< servlet-name > xfire </ servlet-name >
< url-pattern > *.ws </ url-pattern >
</ servlet-mapping >
< servlet >
<!–  配合Spring容器中XFire一起工作的Servlet –>
< servlet-name > xfireServlet </ servlet-name >
< servlet-class > org.codehaus.xfire.spring.XFireSpringServlet </ servlet-class >
</ servlet >
< servlet-mapping >
< servlet-name > xfireServlet </ servlet-name >
<!–  在这个URI下开放Web Service服务  –>
< url-pattern > /service/* </ url-pattern >
</ servlet-mapping >
<!–  end XFire 配置  –>
</ web-app >

2） Web Service 的接口类 HelloWorld.java 和对应实现类 HelloWorldImpl.java

为了用 Web Service 完成 HelloWorld 功能，我们首先在 src/webservice 目录下建立接口类 HelloWold.java 。它仅包含一个 sayHelloWorld(String name) 的方法，其详细内容如下：
package  webservice;

/** */ /**
*HelloWorld的接口类.
*/
public interface HelloWorld  {
/** */ /**
*对名字为name的人打招呼.
*@paramname名字
*@return返回打招呼的字符串
*/
String sayHelloWorld(String name);
}
我们还需要建立一个对应的实现类，来实现sayHelloWorld的功能，该实现类即为HelloWorldImpl.java。该类的详细内容如下：
package  webservice;
/** */ /**
*HelloWorld的实现类.
*/
public class HelloWorldImpl  implements  HelloWorld  {
public  String sayHelloWorld(String name)  {
String helloWorld  =   ” hello, “   +  name;
return  helloWorld;
}
}

3） Spring 配置文件 applicationContext.xml 和 xfire-servlet.xml 的配置

首先我们在 applicationContext.xml 文件中配置对应的 bean —— HelloWorldBean ，该 xml 文件的内容如下：
<? xml version=”1.0″ encoding=”UTF-8″ ?>
<! DOCTYPE beans PUBLIC “-//SPRING//DTD BEAN//EN”
“http://www.springframework.org/dtd/spring-beans.dtd” >
< beans >
< bean  id =”HelloWorldBean”  class =”webservice.HelloWorldImpl” />
</ beans >
这个配置文件很简单，在此不详述。

XFire 为 Spring提供了方便易用的导出器XFireExporter，借助该导出器的支持，我们可以在Spring容器中将一个POJO导出为Web Service。HelloWorld是业务服务类，在此拥有一个sayHelloWorld的方法，我们希望将此方法开放为Web Service。在实际应用中，如果某个类具有众多的方法，而其中的某些方法不需要开放为Web Service的情况下，我们可以定义一个窄接口，该接口中只需定义那些开放为Web Service的业务方法。

将一个业务类所有需要开放为Web Service的方法通过一个窄接口来描述是值得推荐的作法，这让Web Service的接口显得很“干净”。其次，XFire的导出器也需要服务接口的支持，因为它采用基于接口的动态代理技术。

窄接口中的方法在真实的系统中可能需要引用其它的业务类或DAO获取数据库中的真实数据，为了简化实例，我们在此简化了实例。

下面让我们看看在xfire-servlet.xml文件中导出器的设置，该文件内容如下：
<? xml version=”1.0″ encoding=”UTF-8″ ?>
<! DOCTYPE beans PUBLIC “-//SPRING//DTD BEAN//EN”
“http://www.springframework.org/dtd/spring-beans.dtd” >
< beans >
<!–  引入XFire预配置信息  –>
< import  resource =”classpath:org/codehaus/xfire/spring/xfire.xml”   />
<! —定义访问的url– >
< bean  class =”org.springframework.web.servlet.handler.SimpleUrlHandlerMapping” >
< property  name =”urlMap” >
< map >
< entry  key =”/HelloWorldService.ws” >
< ref  bean =”HelloWorldService”   />
</ entry >
</ map >
</ property >
</ bean >

<!–  使用XFire导出器  –>
< bean  id =”baseWebService”  class =”org.codehaus.xfire.spring.remoting.XFireExporter”  lazy-init =”false”  abstract =”true” >
<!–  引用xfire.xml中定义的工厂  –>
< property  name =”serviceFactory”  ref =”xfire.serviceFactory”   />
<!–  引用xfire.xml中的xfire实例  –>
< property  name =”xfire”  ref =”xfire”   />
</ bean >
< bean  id =”HelloWorldService”  parent =”baseWebService” >
<!–  业务服务bean  –>
< property  name =”serviceBean”  ref =”HelloWorldBean”   />
<!–  业务服务bean的窄接口类  –>
< property  name =”serviceClass”  value =”webservice.HelloWorld”   />
</ bean >
</ beans >

在上面的配置中，我们可以看到，在该配置文件中引入了xfire.xml这个Spring配置文件。它是在XFire核心JAR包中拥有一个预定义的 Spring配置文件，它定义了XFire在Spring中必须用到的一些Bean和资源，需要引入这个预定义的配置文件。从该配置文件中可以看出，我们通过XFireExporter将业务类导出为Web Service，对于任何导出器，我们都需要引入XFire环境，即serviceFactory 和 xfire ，这是标准的配置。 ServiceFactory 是XFire的核心类，它可以将一个POJO生成为一个Web Service。

在本实例中，我们通过定义一个baseWebService，其余的webService配置都将该bean作为父bean，这样可以简化Spring的配置，不需要多次引入serviceFactory和xfire。

3. Web Service 的测试

在上一步操作完成之后，我们的这个简单的 Web Service 已经编写完毕，下面让我们来看看自己的劳动成果吧。

在浏览器中输入地址： http://localhost:8080/webservice_helloworld/HelloWorldService.ws?wsdl ，我们可以看到 HelloWorldService 对应的 WSDL 信息， 阅读这个WSDL文档，我们可以知道HelloWorld的sayHelloWorld方法已经被成功地发布为Web Service了。只要拿到这个WSDL就可以开发相应的客户端调用程序了。

XFire 为访问服务端Web Service提供了各种方便的方式：我们一般根据服务地址和窄接口类创建客户调用程序。

在不能获得服务窄接口类的情况下，XFire允许我们通过WSDL文件生成客户端调用程序，通过指定服务接口的方式调用服务。

1） 通过WSDL文件生成客户端调用程序

首先我们通过 http://localhost:8080/webservice_helloworld/HelloWorldService.ws?wsdl 我们可以获得 WSDL 文件 HelloWorldService.wsdl ，并将其放在 src 目录下面，接着我们通过程序访问该 WSDL 文件，并调用需测试的方法。此时测试类 WebServiceClientTest.java 的内容如下所示：
package  test;

import  org.codehaus.xfire.client.Client;
import  org.springframework.core.io.ClassPathResource;
import  org.springframework.core.io.Resource;
import  webservice.HelloWorld;

/** */ /**
*Copyright2007GuangZhouAmigo.
*Allrightreserved.
*HelloWorld的webservice的测试类.
* @author <a href=”mailto:xiexingxing1121@126.com”>AmigoXie</a>
*@version1.0
*Creationdate:2007-9-16-下午05:36:05
*/
public class WebServiceClientTest  {
HelloWorld helloWorld  =   null ;

public static void main(String[] args)  throws  Exception  {
WebServiceClientTest test  =   new  WebServiceClientTest();
test.testClient();
}

public void testClient()  throws  Exception  {
String wsdl  =   ” HelloWorldService.wsdl ” ;  // 对应的WSDL文件
Resource resource  =   new  ClassPathResource(wsdl);
Client client  =   new  Client(resource.getInputStream(),  null );  // 根据WSDL创建客户实例

Object[] objArray  =   new  Object[ 1 ];
objArray[ 0 ]  =   ” 阿蜜果 ” ;
// 调用特定的Web Service方法
Object[] results  =  client.invoke( ” sayHelloWorld ” , objArray);
System.out.println( ” result:  “   +  results[ 0 ]);
}
}

运行该类，可得到如下输出结果：

result: hello, 阿蜜果

可看出运行结果正确。

2 ）根据服务地址创建客户端调用程序

接着让我们来看一个根据服务地址创建客户端调用程序的例子。我们可以通过测试类来测试Web Service的正确性，下面让我们来看一个简单的测试类，首先我们在src/test目录建立 WebServiceClientTest.java 文件，并在 src 目录下建立客户端调用的 Spring 配置文件 client.xml 。在 client.xml 配置文件中我们定义了一个 testWebService 的 bean ，该 bean 访问 wsdlDocumentUrl 为 http://localhost:8080/webservice_helloworld/HelloWorldService.ws?wsdl 的 WSDL 。该 xml 文件的详细内容如下：
<? xml version=”1.0″ encoding=”UTF-8″ ?>
<! DOCTYPE beans PUBLIC “-//SPRING//DTD BEAN//EN”
“http://www.springframework.org/dtd/spring-beans.dtd” >
< beans >
< bean  id =”testWebService”  class =”org.codehaus.xfire.spring.remoting.XFireClientFactoryBean” >
< property  name =”serviceClass” >
< value > webservice.HelloWorld </ value >
</ property >
< property  name =”wsdlDocumentUrl” >
< value > http://localhost:8080/webservice_helloworld/HelloWorldService.ws?wsdl </ value >
</ property >
</ bean >
</ beans >

在 WebServiceClientTest.java 文件中获得 HelloWorld ，并调用它的 sayHelloWorld 方法来完成测试，该类的详细内容如下所示：
package  test;

import  org.springframework.context.ApplicationContext;
import  org.springframework.context.support.ClassPathXmlApplicationContext;
import  webservice.HelloWorld;

/** */ /**
*HelloWorld的webservice的测试类.
*/
public class WebServiceClientTest  {
HelloWorld helloWorld  =   null ;

public static void main(String[] args)  {
WebServiceClientTest test  =   new  WebServiceClientTest();
test.testClient();
}

public void testClient()  {
ApplicationContext ctx  =   new  ClassPathXmlApplicationContext(
” client.xml ” );
helloWorld  =  (HelloWorld) ctx.getBean( ” testWebService ” );
System.out.println(helloWorld.sayHelloWorld( ” 阿蜜果 ” ));
}
}

在启动 webservice_helloworld 工程的情况下，运行 WebServiceClientTest 类，可看到控制台包含如下信息：

hello, 阿蜜果

由此可看出调用 Web Service 成功。

四．总结

与 Axis相比，在实施Web Service时XFire更加简洁高效，并且XFire对Spring提供了强大的支持，可以非常方便地在Spring中使用XFire实施Web Service，因此XFire在短短的时间里成为了受Web Service开发者喜爱的框架。

XFire为客户端提供了多种访问Web Service的方式，如果可以获取客户端的窄接口类，则可以采用窄接口类调用Web Service。如果仅能获取WSDL，XFire也可以采用动态反射的机制调用Web Service。XFire为Eclipse提供了一个可以根据WSDL生成客户端存根代码的插件，相信XFire也将为其它非Java语言提供类似的插件。

技术可用性的一个很大的标准是它是否方便测试，XFire提供多种方式进行Web Service的测试，简单方便，给Web Service开发人员的测试工作带来了福音。

在本文中，笔者通过一个简单的helloWorld的Web Service例子，详细地说明了用XFire+Spring构建Web Service时配置文件的相关配置，以及测试的各种方法，也让读者见识了XFire与Spring的无缝集成，希望对读者学习XFire有点帮助。

]]> http://javadou.com/xfire-webservice-service-client-507/feed/ 0 WebService完全实例详细解析 http://javadou.com/webservice-xml-study-506/ http://javadou.com/webservice-xml-study-506/#comments Tue, 09 Feb 2010 07:00:41 +0000 阿超 http://javadou.com/?p=506 首先,我们必须了解什么是webservice.就概念上来说,可能比较复杂,不过我们可以有个宏观的了解:webservice就是个对外的接口,里面 有 函数可供外部客户调用(注意:里面同样有客户不可调用的函数).假若我们是服务端,我们写好了个webservice,然后把它给了客户(同时我们给了他 们调用规则),客户就可以在从服务端获取信息时处于一个相对透明的状态.即是客户不了解(也不需要)其过程,他们只获取数据.

webservice传递的数据只能是序列化的数据,典型的就是xml数据,这里我们也只讨论xml数据的传输.

有了一些对xml webservice的初步了解后,我们将切入正题,即是用一个具体的webservice事例的形式来讲解具体的webservice用法,用具体的事例来讲解一个概念我想怎么也要比单纯的说理能让人容易理解吧.

这里,我们将以一个简单的分布式课件搜索系统为例来讲解.使用VS2003为编译环境,C#为语言,SqlServcer2000为数据库.(这个例子来 源于一位网上朋友的文章的启发,觉得很能代表webservice的特点,就按那个想法做了这么个系统来示例了)

首先,明确我们要做什么.我们需要一个对客户的接口,也就是个站点,我们把它称做ServiceGatherSite,它是何种形式都无所谓, 甚至它本身 并不需要数据库,它只是提供给用户一个查询的接口,真正的服务,普通用户是不接触到的.然后,这里我们还需要若干个提供服务的站点,我们可以称它们为资源 站,这里为简单起见,假设有两个资源站,分别叫WebSiteA,WebSiteB,它们可以是不对外公布的,只是为了丰富查询数据而存在.最后,是我们 最需要关注的东西—资源站提供给ServiceGatherSite的服务.两个资源站,就有两个服务,我们称为SiteAService和 SiteBService.两个服务间没有任何关系,内部提供的方法也完全没关联,只是需要把方法如何使用告诉ServiceGatherSite,意思 是,服务只提供查询接口,返回的数据如何处理,服务本身并不管,全由使用服务的站点分配.

写了这么多,算是简要的介绍了下有关xml webservice的概念和我们这个例子的结构,下篇文章,我们将开始真正进入代码的设计阶段.

上篇文章介绍了些webservice的基本特性和我们例子的结构,这篇文章我们将开始具体的代码编写工作.

这个专题主要讲述的是webservice,因此这里我们的代码以Webservice相关为主,而其他工程,例如:ServiceGatherSite,WebSiteA等,只将简略介绍.

在VS2003中,开发一个webservice并不是件困难的事,首先,我们新建一个webservice项目(文件->新建->项目->C#->Web服务应用程序)

建完这个工程,我们将看到一个叫Service1.asmx的文件,这就是webservice的标准文件,它也有UI的概念,不过我们一般不 关注,因 此,我们查看其cs代码文件.如果你什么都还没做的话,将看见一个被注释掉的helloworld的WebMethod,把注释去掉,在运行,你就可以得 到最简单的webservice运行实例了.点击”helloworld”将执行其方法.显然,这个函数对我们的意义只在于宏观的了解了下web服务的写 法.

下面,我们将开始具体介绍webservice的写法.在代码文件里,如果我们写了一个函数后,希望此函数成为外部可调用的接口函数,我们必须 在函数上面 添上一行代码[WebMethod(Description="函数的描述信息")],如果你的函数没有这个申明,它将不能被用户引用.如:

以下是引用片段：

[WebMethod(Description="最简单的方法")]public string HelloWorld()

{

return “Hello World”;

}

这个函数就是外部可调用的接口函数,对用户来说相当于一个API.如果某用户在引用了这个服务后,他调用HelloWorld()方法,他就将获得”HelloWorld”这个返回值.

看到这里,我们是不是发现,其实webservice并不是那么的神秘,它也不过只是个接口,对我们而言,侧重点依然是接口函数的编写.下面,我将给出我们的例子所需要的接口函数.

[WebMethod(Description="查询以获取需要的课件信息")]public XmlDataDocument GetSiteAData(string AssignName)

{

XmlDataDocument xd=new XmlDataDocument(); //

DataSet ds=new DataSet();

CStoreProc cp=new CStoreProc(“SearchAssign”);

cp.AddParIn(“@keywords”,SqlDbType.VarChar,30,AssignName);

cp.AddParOut(“@res”,SqlDbType.Int);

if(cp.SelectProc()) //如果执行成功,存储过程

{

cp.myData.EnforceConstraints=false; //不进行格式严格检查

if((int)cp.GetReturnValue(“@res”)==-1)

{

string xml=”";

xd.LoadXml(xml);

return xd;

}

xd=new XmlDataDocument(cp.myData);

XmlNode root1=xd.DocumentElement;

XmlNodeList roots=root1.SelectNodes(“list”);

foreach(XmlNode roota in roots) //为所有元素加上站点名称标记

{

XmlElement Link=xd.CreateElement(“SiteName”);

Link.InnerText=ConfigurationSettings.AppSettings["SiteName"].ToString();

roota.AppendChild(Link);

}

return xd;

}

else return null;

}

这是获取资源站点信息的一个接口函数.里面大部分的代码,我想对于有一定asp.net基础的朋友来说,都应该是一看就明白,这里只说明下CStoreProc,这是我封装的一个存储过程类,主要功能是执行各种类型的存储过程.

细心的朋友可能会发现这个函数的返回类型似乎比较特殊,是个xml的文档.我们在前面已经说过,webservice只能传输序列化数据,xml显 然满足 条件,但比如hash表之类的非序列化数据,是不能传输的,xml使用最为广泛,而且考虑到跨平台应用,所以这里我们只以xml数据的传输来示例.

接上篇文章,我们先简单解释下GetSiteAData(string AssignName)函数.

函数功能很简单,只是要返回查询结果,其数据格式是XmlDataDocument.当查询失败时(无匹配查询结果),我们构造一个xml,返 回一个空记 录.否则,我们把查询后的dataset生成一个XmlDataDocument,接下来,由于该项目的需要,我加入了一个循环,添加dataset里所 没有的节点,站点名称.在这之后,算是完成了一个符合我们期望格式的xml数据文档,我们把它返回.

好了,webservice的方法函数介绍完了(这里还有个web服务方法,稍后介绍),接下来我们的任务是怎么调用它了.首先把 webservice的 项目编译完成,假定我们这个服务是针对资源站点A的,我们不妨称其为ServiceA.先单独运行asmx文件,执行GetSiteAData (string AssignName)方法,将提示你输入参数,你输入要搜索的内容,点确认,将返回给你一个xml数据,并在ie上显示出来,这就是你搜索到的内容拉.

这里对ServiceA的工作再做点介绍,在我们这个项目里,它是资源站点A提供的服务,意思是,它查询的数据将全来源于站点A,而站点A资源添加在本项目也有专门的工程实现.

好了,回到正题.这里我介绍vs调用webservice的方法,其实其他平台的调用方法也是大同小异.首先我们介绍web引用方式,这种方式 我强烈建议 调试时使用,非常方便.右击引用,点添加web引用,输入你的webservice地址,如:http: //localhost/aspxproject/WebServiceSolution/SiteBService/service1.asmx,你必 须保证你输入的webservice存在.然后引用即可,注意:web引用名将作为你加入的webservice的名字空间.比如你输入了:SiteA, 那服务的实例化将是这样:SiteA.Service1 serviceA=new SiteA.Service1();(Service1是服务的类名).

完成了这一步,service的调用似乎变的那么简单,我们已经实现了远程实例化,接下来的远程调用也是一样的容易.下面给出资源采集站ServiceGatherSite的绑定代码(只采集A站点的信息)

以下是引用片段：

//绑定数据public void BindData()

{

serviceA=new SiteA.Service1();

DataSet ds=new DataSet();

XmlNode xmlNode1;

XmlDataDocument xd=new XmlDataDocument();

StringBuilder xmlString1;

xmlNode1=serviceA.GetSiteAData(strSearch);

if(xmlNode1==null) //–存储过程执行失败

return;

xmlString1=new StringBuilder(xmlNode1.OuterXml);

if(xmlString1.ToString().Equals(“”))

return ;

xd.LoadXml(xmlString1.ToString());

ds.ReadXml(new XmlNodeReader(xd));

DataGrid1.DataSource=ds.Tables["list"].DefaultView;

DataGrid1.DataBind();

}

此段代码给出了xml转化成dataset的解决方案,虽然这不是必须的,但毕竟在asp.net里,dataset占的作用之重,谁都知道的.其 他的请 朋友们先看(呵呵,个中高手就免了),在下篇文章中将会有对它的一些解释与及多服务分布调用的解决方案,写了三篇了,发现似乎还是有些朋友看的,那我就献 丑继续写下去好了,大家有什么意见也希望提出,在下的理解存在偏驳也再所难免,希望谅解:)

接上篇文章,我们先简单说明下绑定函数.首先实例化ServiceA,这个和一般类的实例化并没有不同..接下来用xmlNode1来接受函数的返回值,接下来是构造xml,并将其转化为dataset,这是通用的方法,如果是刚接触不久的朋友,最好能记下这种方法.

接下来给出异步调用两个服务的代码

以下是引用片段：

//绑定数据public void BindData()

{

IAsyncResult ar1;

IAsyncResult ar2;

serviceA=new SiteA.Service1();

serviceB=new SiteB.Service1();

DataSet ds=new DataSet();

XmlNode xmlNode1,xmlNode2;

XmlDataDocument xd=new XmlDataDocument();

StringBuilder xmlString1,xmlString2;

//–简单的异步调用

ar1=serviceA.BeginGetSiteAData(strSearch,null,null);

ar2=serviceB.BeginGetSiteAData(strSearch,null,null);

xmlNode1=serviceA.EndGetSiteAData(ar1);

xmlNode2=serviceB.EndGetSiteAData(ar2);

//———-

if(xmlNode1==null&&xmlNode2==null) //–存储过程执行失败

return;

xmlString1=new StringBuilder(xmlNode1.OuterXml);

xmlString2=new StringBuilder(xmlNode2.OuterXml);

xmlString1=MakeNewXmlString(xmlString1,xmlString2); //生成新的xml

if(xmlString1.ToString().Equals(“”))

return ;

xd.LoadXml(xmlString1.ToString());

ds.ReadXml(new XmlNodeReader(xd));

DataGrid1.DataSource=ds.Tables["list"].DefaultView;

DataGrid1.DataBind();

}

//生成新XML

public StringBuilder MakeNewXmlString(StringBuilder str1,StringBuilder str2)

{

str1=str1.Replace(“”,”");

str2=str2.Replace(“”,”");

str1.Append(str2.ToString());

return str1;

}

这有两个需要注意的地方,一个是xml构造,还有就是异步调用的实现,请读者,自己理解

下面讲下通过dll来引用webservice的方法,我只把流程介绍下.

首先,在ie输入服务的地址,如:http://www.xxx.com/service.asmx

然后写输入http://www.xxx.com/service.asmx?wsdl

打开后,另存为xxx.wsdl

然后用vs的命令提示符来编译:wsdl /namespace:SiteA ServiceA.wsdl

生成名字空间为sitea的代理类

最后csc /out:ServiceA.dll /t:library Service1.cs ,其中service1.cs为代理类文件

最后引用dll就可以了.

]]> http://javadou.com/webservice-xml-study-506/feed/ 0 简单介绍webservice和soap小原理 http://javadou.com/start-webservice-and-soap-505/ http://javadou.com/start-webservice-and-soap-505/#comments Mon, 08 Feb 2010 06:58:20 +0000 阿超 http://javadou.com/?p=505 从表面上看，Web service 就是一个应用程序，它向外界暴露出一个能够通过Web进行调用的API。也就是说，可以利用编程的方法通过Web来调用这个应用程序。

对Web service 更精确的解释: Web services是建立可互操作的分布式应用程序的新平台。Web service平台是一套标准，它定义了应用程序如何在Web上实现互操作性。你可以用任何你喜欢的语言，在任何你喜欢的平台上写Web service ，只要我们可以通过Web service标准对这些服务进行查询和访问。

不管你的Web service是用什么工具，什么语言写出来的，只要你用SOAP协议通过HTTP来调用它，总体结构都一致。通常，你用你自己喜欢的语言(如VB 6或者VB.NET)来构建你的Web service，然后用SOAP Toolkit或者.NET的内建支持来把它暴露给Web客户。于是，任何语言，任何平台上的客户都可以阅读其WSDL文档，以调用这个Web service。客户根据WSDL描述文档，会生成一个SOAP请求消息。Web service都是放在Web服务器 (如IIS) 后面的，客户生成的SOAP请求会被嵌入在一个HTTP POST请求中，发送到Web服务器来。Web服务器再把这些请求转发给Web service请求处理器。请求处理器的作用在于，解析收到的SOAP请求，调用Web service，然后再生成相应的SOAP应答。Web服务器得到SOAP应答后，会再通过HTTP应答的方式把它送回到客户端。 bbs.bitsCN.com中国网管论坛

基本概念

SOAP

XML和XSD

WSDL(Web Services Description Language)

WSML(Web Services Meta Language)

什么时候使用Web Services

Web service是创建可互操作的分布式应用程序的新平台。Web service 的主要目标是跨平台的可互操作性。为了达到这一目标，Web service 是完全基于XML、XSD等独立于平台、独立于软件供应商的标准的。

Web service在应用程序跨平台和跨网络进行通信的时候是非常有用的。Web service适用于应用程序集成、B2B集成、代码和数据重用，以及通过Web进行客户端和服务器的通信的场合。

当然，Web service也不是万能的，你不能到处滥用Web service。在有些情况下，Web service 会降低应用程序的性能，而不会带来任何好处。例如，一台机器或一个局域网里面运行的同构应用程序就不应该用Web service 进行通信。

如何调用Web Services

客户端:取得服务端的服务描述文件WSDL，解析该文件的内容，了解服务端的服务信息，以及调用方式。根据需要，生成恰当的SOAP请求消息(指定调用的方法，已经调用的参数)，发往服务端。等待服务端返回的SOAP回应消息，解析得到返回值。
服务端:生成服务描述文件，以供客户端获取。接收客户端发来的SOAP请求消息，解析其中的方法调用和参数格式。根据WSDL和WSML的描述，调用相应的COM对象来完成指定功能，并把返回值放入SOAP回应消息返回给用户。

高层接口

使用高层接口，不需要知道SOAP和XML的任何信息，就可以生成和使用一个WebService。Soap Toolkit 2.0通过提供两个COM对象――SoapClient和SoapServer，来完成这些功能。

在客户端，只需要生成一个SoapClient实例，并用WSDL作为参数来调用其中的mssoapinit方法。SoapClient对象会自动解析 WSDL文件，并在内部生成所有Web Service的方法和参数信息。之后，你就可以像调用IDispatch接口里的方法一样，调用里面所有的方法。在VB或是脚本语言里，你甚至可以直接 在SoapClient对象名后面直接加上.方法(参数…)进行调用。

低层接口

要使用低层接口，你必须对SOAP和XML有所了解。你可以对SOAP的处理过程进行控制，特别是要做特殊处理的时候。

在客户端，首先要创建一个HttpConnector对象，负责HTTP连接。设定Connector的一些头部信息，比如EndPoinURL和 SoapAction等。如果网络连接需要使用代理服务器，那也要在这里设定相关的信息。接着创建SoapSerializer对象，用于生成Soap消 息。按照WSDL里定义，把所有参数按顺序序列化，得到一个完整的SOAP请求消息。该Soap消息，作为Payload通过HttpConnector 被发送到服务端。最后，生成一个SoapReader对象，负责读取服务端返回的SOAP消息，取得其中的返回值。

]]> http://javadou.com/start-webservice-and-soap-505/feed/ 0