计算器之webservice实现

以下是本人原创，如若转载和使用请注明转载地址。本博客信息切勿用于商业，可以个人使用，若喜欢我的博客，请关注我，谢谢！博客地址

一、根据我的上一篇博客

MyEclipse构建Web Service（Xfire框架）

下面是我实现的网页版的计算器，本来想着用php去调用webservice的接口，由于时间原因，现在用java去调用webservice接口。

再根据原先实现过的吧B/S 架构的计算器作业，现将网页说明博客如下：

Ext实现简单计算器

二、编写自己的类

根据上一篇博客的说明我们建立一个用于实现计算器的webservice类ExpWebService.java，其代码如下所示：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
package server;
 
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
 
import org.apache.commons.jexl.Expression;
import org.apache.commons.jexl.ExpressionFactory;
import org.apache.commons.jexl.JexlContext;
import org.apache.commons.jexl.JexlHelper;
 
/**
 *
* 项目名称：CalculatorWebService 
* 类名称：ExpWebService 
* 类描述： 
* 创建人：王少帅 
* 创建时间：2013-12-12 下午02:58:32      
* @version
 */
public class ExpWebService {
     
    /**
     *
    * expCalculator(使用jexl自带的方式处理exp得到计算器的值) 
    * @param name
    * @return String
    * @Exception
     */
    public String expCalculator(String exp) throws Exception {
        // TODO Auto-generated method stub
        Expression e = ExpressionFactory.createExpression(exp);//使用提供的expression提供的方法
        JexlContext jc = JexlHelper.createContext();
        Object result = e.evaluate(jc);//计算出结果
        return result.toString();
    }
     
}

三、客户端去调用相应的webservice，这里是CalculatorWebService

我们先new->webservice client 之后新建项目叫Calculator01，将服务器端的wsdl的url添加好即可，现在我们用到页面去实现计算器的功能，这里我们客户端（其实也在服务器端，以为是B/S 架构的），我们去调用CalculatorWebService提供的方法ExpWebService来求出计算结果。

下面是包的结构：

之后我们看到我们的action中类CalculatorAction.java中的代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
package com.wss.action;
 
import javax.servlet.http.HttpServletResponse;
 
import org.apache.struts2.ServletActionContext;
 
import server.CalculatorWebServiceClient;
import server.CalculatorWebServicePortType;
 
/**
 *
* 项目名称：Calculator01 
* 类名称：CalculatorAction 
* 类描述：  接收客户端的计算式来计算结果
* 创建人：王少帅 
* 创建时间：2013-12-12 下午03:50:32      
* @version
 */
public class CalculatorAction {
    public String exp;
 
    public String getExp() {
        return exp;
    }
 
    public void setExp(String exp) {
        this.exp = exp;
    }
     
    public void execute() throws Exception{
 
        //这里使用webserviceClient来调用webservice的方法
        CalculatorWebServiceClient calculatorWebServiceClient = new CalculatorWebServiceClient();
        CalculatorWebServicePortType service  = calculatorWebServiceClient.getCalculatorWebServiceHttpPort();
         
        String result = service.expCalculator(exp); //调用expCalculator方法来实现
         
        HttpServletResponse response = ServletActionContext.getResponse();//返回页面进行查看
 
        response.getWriter().write(result);
         
    }
     
}

四、自动生成的文件分析

如图自动生成的文件：


下面是CalculatorWebServiceClient.java的文件内容：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
package server;
 
import java.net.MalformedURLException;
import java.util.Collection;
import java.util.HashMap;
import javax.xml.namespace.QName;
import org.codehaus.xfire.XFireRuntimeException;
import org.codehaus.xfire.aegis.AegisBindingProvider;
import org.codehaus.xfire.annotations.AnnotationServiceFactory;
import org.codehaus.xfire.annotations.jsr181.Jsr181WebAnnotations;
import org.codehaus.xfire.client.XFireProxyFactory;
import org.codehaus.xfire.jaxb2.JaxbTypeRegistry;
import org.codehaus.xfire.service.Endpoint;
import org.codehaus.xfire.service.Service;
import org.codehaus.xfire.soap.AbstractSoapBinding;
import org.codehaus.xfire.transport.TransportManager;
 
public class CalculatorWebServiceClient {
 
    private static XFireProxyFactory proxyFactory = new XFireProxyFactory();
    private HashMap endpoints = new HashMap();
    private Service service0;
 
    public CalculatorWebServiceClient() {
        create0();
        Endpoint CalculatorWebServicePortTypeLocalEndpointEP = service0 .addEndpoint(new QName("http://server", "CalculatorWebServicePortTypeLocalEndpoint"), new QName("http://server", "CalculatorWebServicePortTypeLocalBinding"), "xfire.local://CalculatorWebService");
        endpoints.put(new QName("http://server", "CalculatorWebServicePortTypeLocalEndpoint"), CalculatorWebServicePortTypeLocalEndpointEP);
        Endpoint CalculatorWebServiceHttpPortEP = service0 .addEndpoint(new QName("http://server", "CalculatorWebServiceHttpPort"), new QName("http://server", "CalculatorWebServiceHttpBinding"), "http://localhost:8080/CalculatorWebService/services/CalculatorWebService");
        endpoints.put(new QName("http://server", "CalculatorWebServiceHttpPort"), CalculatorWebServiceHttpPortEP);
    }
 
    public Object getEndpoint(Endpoint endpoint) {
        try {
            return proxyFactory.create((endpoint).getBinding(), (endpoint).getUrl());
        } catch (MalformedURLException e) {
            throw new XFireRuntimeException("Invalid URL", e);
        }
    }
 
    public Object getEndpoint(QName name) {
        Endpoint endpoint = ((Endpoint) endpoints.get((name)));
        if ((endpoint) == null) {
            throw new IllegalStateException("No such endpoint!");
        }
        return getEndpoint((endpoint));
    }
 
    public Collection getEndpoints() {
        return endpoints.values();
    }
 
    private void create0() {
        TransportManager tm = (org.codehaus.xfire.XFireFactory.newInstance().getXFire().getTransportManager());
        HashMap props = new HashMap();
        props.put("annotations.allow.interface", true);
        AnnotationServiceFactory asf = new AnnotationServiceFactory(new Jsr181WebAnnotations(), tm, new AegisBindingProvider(new JaxbTypeRegistry()));
        asf.setBindingCreationEnabled(false);
        service0 = asf.create((server.CalculatorWebServicePortType.class), props);
        {
            AbstractSoapBinding soapBinding = asf.createSoap11Binding(service0, new QName("http://server", "CalculatorWebServicePortTypeLocalBinding"), "urn:xfire:transport:local");
        }
        {
            AbstractSoapBinding soapBinding = asf.createSoap11Binding(service0, new QName("http://server", "CalculatorWebServiceHttpBinding"), "http://schemas.xmlsoap.org/soap/http");
        }
    }
 
    public CalculatorWebServicePortType getCalculatorWebServicePortTypeLocalEndpoint() {
        return ((CalculatorWebServicePortType)(this).getEndpoint(new QName("http://server", "CalculatorWebServicePortTypeLocalEndpoint")));
    }
 
    public CalculatorWebServicePortType getCalculatorWebServicePortTypeLocalEndpoint(String url) {
        CalculatorWebServicePortType var = getCalculatorWebServicePortTypeLocalEndpoint();
        org.codehaus.xfire.client.Client.getInstance(var).setUrl(url);
        return var;
    }
 
    public CalculatorWebServicePortType getCalculatorWebServiceHttpPort() {
        return ((CalculatorWebServicePortType)(this).getEndpoint(new QName("http://server", "CalculatorWebServiceHttpPort")));
    }
 
    public CalculatorWebServicePortType getCalculatorWebServiceHttpPort(String url) {
        CalculatorWebServicePortType var = getCalculatorWebServiceHttpPort();
        org.codehaus.xfire.client.Client.getInstance(var).setUrl(url);
        return var;
    }
 
    public static void main(String[] args) {
         
 
        CalculatorWebServiceClient client = new CalculatorWebServiceClient();
         
        //create a default service endpoint
        CalculatorWebServicePortType service = client.getCalculatorWebServiceHttpPort();
         
        //TODO: Add custom client code here
                //
                //service.yourServiceOperationHere();
         
        System.out.println("test client completed");
                System.exit(0);
    }
 
}


下面这个是CalculatorWebServicePortType.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
package server;
 
import javax.jws.WebMethod;
import javax.jws.WebParam;
import javax.jws.WebResult;
import javax.jws.WebService;
import javax.jws.soap.SOAPBinding;
 
@WebService(name = "CalculatorWebServicePortType", targetNamespace = "http://server")
@SOAPBinding(use = SOAPBinding.Use.LITERAL, parameterStyle = SOAPBinding.ParameterStyle.WRAPPED)
public interface CalculatorWebServicePortType {
 
    @WebMethod(operationName = "expCalculator", action = "")
    @WebResult(name = "out", targetNamespace = "http://server")
    public String expCalculator(
            @WebParam(name = "exp", targetNamespace = "http://server") String exp);
 
}


这个是ExpCalculator.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
package server;
 
import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;
import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlRootElement;
import javax.xml.bind.annotation.XmlType;
 
 
/**
 * <p>Java class for anonymous complex type.
 *
 * <p>The following schema fragment specifies the expected content contained within this class.
 *
 * <pre>
 * &lt;complexType>
 *   &lt;complexContent>
 *     &lt;restriction base="{http://www.w3.org/2001/XMLSchema}anyType">
 *       &lt;sequence>
 *         &lt;element name="exp" type="{http://www.w3.org/2001/XMLSchema}string"/>
 *       &lt;/sequence>
 *     &lt;/restriction>
 *   &lt;/complexContent>
 * &lt;/complexType>
 * </pre>
 *
 *
 */
@XmlAccessorType(XmlAccessType.FIELD)
@XmlType(name = "", propOrder = {
    "exp"
})
@XmlRootElement(name = "expCalculator")
public class ExpCalculator {
 
    @XmlElement(required = true, nillable = true)
    protected String exp;
 
    /**
     * Gets the value of the exp property.
     *
     * @return
     *     possible object is
     *     {@link String }
     *    
     */
    public String getExp() {
        return exp;
    }
 
    /**
     * Sets the value of the exp property.
     *
     * @param value
     *     allowed object is
     *     {@link String }
     *    
     */
    public void setExp(String value) {
        this.exp = value;
    }
 
}


这个是ExpCalculatorResponse.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
package server;
 
import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;
import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlRootElement;
import javax.xml.bind.annotation.XmlType;
 
 
/**
 * <p>Java class for anonymous complex type.
 *
 * <p>The following schema fragment specifies the expected content contained within this class.
 *
 * <pre>
 * &lt;complexType>
 *   &lt;complexContent>
 *     &lt;restriction base="{http://www.w3.org/2001/XMLSchema}anyType">
 *       &lt;sequence>
 *         &lt;element name="out" type="{http://www.w3.org/2001/XMLSchema}string"/>
 *       &lt;/sequence>
 *     &lt;/restriction>
 *   &lt;/complexContent>
 * &lt;/complexType>
 * </pre>
 *
 *
 */
@XmlAccessorType(XmlAccessType.FIELD)
@XmlType(name = "", propOrder = {
    "out"
})
@XmlRootElement(name = "expCalculatorResponse")
public class ExpCalculatorResponse {
 
    @XmlElement(required = true, nillable = true)
    protected String out;
 
    /**
     * Gets the value of the out property.
     *
     * @return
     *     possible object is
     *     {@link String }
     *    
     */
    public String getOut() {
        return out;
    }
 
    /**
     * Sets the value of the out property.
     *
     * @param value
     *     allowed object is
     *     {@link String }
     *    
     */
    public void setOut(String value) {
        this.out = value;
    }
 
}


这个是ObjectFactory.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
package server;
 
import javax.xml.bind.annotation.XmlRegistry;
 
 
/**
 * This object contains factory methods for each
 * Java content interface and Java element interface
 * generated in the server package.
 * <p>An ObjectFactory allows you to programatically
 * construct new instances of the Java representation
 * for XML content. The Java representation of XML
 * content can consist of schema derived interfaces
 * and classes representing the binding of schema
 * type definitions, element declarations and model
 * groups.  Factory methods for each of these are
 * provided in this class.
 *
 */
@XmlRegistry
public class ObjectFactory {
 
 
    /**
     * Create a new ObjectFactory that can be used to create new instances of schema derived classes for package: server
     *
     */
    public ObjectFactory() {
    }
 
    /**
     * Create an instance of {@link ExpCalculator }
     *
     */
    public ExpCalculator createExpCalculator() {
        return new ExpCalculator();
    }
 
    /**
     * Create an instance of {@link ExpCalculatorResponse }
     *
     */
    public ExpCalculatorResponse createExpCalculatorResponse() {
        return new ExpCalculatorResponse();
    }
 
}


这个是package-info.java

1
2
@javax.xml.bind.annotation.XmlSchema(namespace = "http://server", elementFormDefault = javax.xml.bind.annotation.XmlNsForm.QUALIFIED)
package server;



感谢您支持我的博客，我的动力是您的支持和关注！如若转载和使用请注明转载地址，并且请尊重劳动成果，谢谢！


















posted @ 2013-12-12 16:00  Tim&Blog  阅读(897)  评论(0)    收藏  举报