# webservice
**Repository Path**: relaxy/webservice
## Basic Information
- **Project Name**: webservice
- **Description**: webservice的发布与调用
- **Primary Language**: Unknown
- **License**: Not specified
- **Default Branch**: master
- **Homepage**: None
- **GVP Project**: No
## Statistics
- **Stars**: 1
- **Forks**: 1
- **Created**: 2020-08-04
- **Last Updated**: 2021-07-07
## Categories & Tags
**Categories**: Uncategorized
**Tags**: None
## README
# webservice笔记
**XML(Extensible Markup Language)** :扩展型可标记语言。面向短期的临时数据处理、面向万维网络,是Soap的基础。
**SOAP(Simple Object Access Protocol)** :简单对象存取协议。是XML Web Service 的通信协议。当用户通过UDDI找到你的WSDL描述文档后,他通过可以SOAP调用你建立的Web服务中的一个或多个操作。SOAP是XML文档形式的调用方法的规范,它可以支持不同的底层接口,像HTTP(S)或者SMTP。
**WSDL(Web Services Description Language)** :WSDL 文件是一个 XML 文档,用于说明一组 SOAP 消息以及如何交换这些消息。大多数情况下由软件自动生成和使用。
**UDDI (Universal Description, Discovery, and Integration)** :**通用描述、发现与集成服务**,是一个主要针对Web服务供应商和使用者的新项目。在用户能够调用Web服务之前,必须确定这个服务内包含哪些商务方法,找到被调用的接口定义,还要在服务端来编制软件,UDDI是一种根据描述文档来引导系统查找相应服务的机制。UDDI利用SOAP消息机制(标准的XML/HTTP)来发布,编辑,浏览以及查找注册信息。它采用XML格式来封装各种不同类型的数据,并且发送到注册中心或者由注册中心来返回需要的数据。
## 什么是webservice?
类似RPC,或者说是RPC的一种实现,可以在网上调用其他人提供的服务。是一种跨平台,跨语言的规范,用于不同平台,不同语言开发的应用之间的交互(远程调用技术)。通过**SOAP** 在Web上提供的软件服务,使用**WSDL**文件进行说明,并通过**UDDI**进行注册。
如你现在要调别人的服务,可以通过**UDDI**找到对应的**WSDL**查看对应的服务,需要什么参数,有什么返回结果等,通过**SOAP**调用你的服务。
## 为什么要学习web service?
大多数对外接口会实现web service方法而不是http方法,如果你不会,那就没有办法对接。
## web service相对http (post/get)有好处,区别吗?
- 接口中实现的方法和要求参数一目了然
- 不用担心大小写问题
- 不用担心中文urlencode问题
- 代码中不用多次声明认证(账号,密码)参数
- 传递参数可以为数组,对象等...
- **httpservice通过post和get得到你想要的东西**
- **webservice就是使用soap协议得到你想要的东西,相比httpservice能处理些更加复杂的数据类型**
- **http协议传输的都是字符串了,webservice则是包装成了更复杂的对象。**
1. webservice走HTTP协议和8
2. 而你说的api,用的协议和端口,是根据开发人员定义的。
3. 这么说吧,api类似于cs架构,需要同时开发客户端API和服务器端程序。
4. 而WebService则类似于bs架构,只需要开发服务器端,不需要开发客户端,客户端只要遵循soap协议,就可以调用。
## webservice解决了什么问题?
- 异构系统之间的通信
- 一些公共资源的调用
## 使用jdk的方式(jws)发布webservice服务
**1、定义一个查询天气的服务接口**
```java
public interface IWeatherService {
String query(String cityName);
}
```
**2、接口实现类**
```java
@WebService
public class IWeatherServiceImpl implements IWeatherService {
@Override
public String query(String cityName) {
Random random = new Random();
int n = random.nextInt(3);
String weather = n==2? "晴天":n==1?"阴天":"暴雨";
System.out.println("查询-> "+cityName+" 的天气为:"+weather);
return weather;
}
}
```
**3、通过jws发布**
```java
public class Main {
public static void main(String[] args) {
Endpoint.publish("http://localhost:8080/weatherService",new IWeatherServiceImpl());
System.out.println("发布成功");
}
}
```
**4、在浏览器上通过http://localhost:8080/weatherService?wsdl 就可以查看相关的wsdl文档**
```xml
This XML file does not appear to have any style information associated with it. The document tree is shown below.
```
**通过wsdl文档里的http://localhost:8080/weatherService?xsd=1去查看相关的方法信息**
```html
This XML file does not appear to have any style information associated with it. The document tree is shown below.
```
### 总结
**目标:**通过JDK来发布webservice服务
**步骤:**
1. 创建接口
2. 创建实现类 + @WebService
3. 发布服务 Endpoint.publish("http://localhost:8080/weatherService",new IWeatherServiceImpl());
## 创建客户端调用刚发布的服务(方案一)
**进到创建的java项目目录下** (如:D:\GitHub\webservice\webservice_client_1\src),
**使用命令** : wsimport -s . http://localhost:8080/weatherService?wsdl
cmd窗口如下:
```
D:\GitHub\webservice\webservice_client_1\src>wsimport -s . http://localhost:8080/weatherService?wsdl
正在解析 WSDL...
正在生成代码...
正在编译代码...
```
**src目录下生成的对象如下:**

调用发布的webservice服务
```java
public class Client {
public static void main(String[] args) {
//1、创建服务视图对象(视图是从service标签的name属性获取 ---> )
IWeatherServiceImplService service = new IWeatherServiceImplService();
//2、获取服务的实现类(实现类从portType标签的name属性获取 ---> )
IWeatherServiceImpl port = service.getPort(IWeatherServiceImpl.class);
//3、调用方法(从portType的operation标签获取 ---> query就是方法名)
String query = port.query("广州");
//输出返回结果
System.out.println(query);
}
}
```
### 总结
目标:通过编程来访问webservice服务
步骤:
1. 生成客户端代码 wsimport
2. 查看服务的说明书
http://localhost:8080/weatherService?wsdl
3. 按照服务的说明书来编程
关键节点: **服务视图**
**实现类**的名称
要**调用的方法**
## 创建客户端调用刚发布的服务(方案二)
**进到创建的java项目目录下** (如:D:\GitHub\webservice\webservice_client_2\src),
**使用命令** : wsimport -s . http://localhost:8080/weatherService?wsdl
调用发布的webservice服务
```java
public class Client {
public static void main(String[] args) throws MalformedURLException {
URL url = new URL("http://localhost:8080/weatherService?wsdl");
//在
修改为
之后,**以绝对路径是方式来生成对应的客户端代码**即可
wsimport -s . D:\GitHub\webservice\webservice_network_client_4\weather.wsdl
2、编写代码调用服务
```java
public class Client {
public static void main(String[] args) {
//1、创建服务视图对象
WeatherWS weatherWS = new WeatherWS();
//2、创建服务的实体类
WeatherWSSoap weatherWSSoap = weatherWS.getWeatherWSSoap();
//3、调用方法
/* 其他方法
getRegionCountry
获得国外国家名称和与之对应的ID 输入参数:无, 返回数据:一维字符串数组。
getRegionDataset
获得中国省份、直辖市、地区;国家名称(国外)和与之对应的ID 输入参数:无,返回数据:DataSet。
getRegionProvince
获得中国省份、直辖市、地区和与之对应的ID 输入参数:无,返回数据:一维字符串数组。
getSupportCityDataset
获得支持的城市/地区名称和与之对应的ID 输入参数:theRegionCode = 省市、国家ID或名称,返回数据:DataSet。
*/
//获得支持的城市/地区名称和与之对应的ID 输入参数:theRegionCode = 省市、国家ID或名称, 返回数据:一维字符串数组。
ArrayOfString sh = weatherWSSoap.getSupportCityString("上海");
//获得天气预报数据 输入参数:城市/地区ID或名称, 返回数据:一维字符串数组。
ArrayOfString cityWeather = weatherWSSoap.getWeather("广州", null);
//4、输出返回结果
System.out.println(sh.getString());
System.out.println(cityWeather.getString());
}
}
```
### 中英翻译
1、通过服务的服务地址,生成客户端代码
**使用命令** : wsimport -s . http://fy.webxml.com.cn/webservices/EnglishChinese.asmx?wsdl
依旧是报错,按照上面的方式生成客户端代码
wsimport -s . D:\GitHub\webservice\webservice_network_client_5\translate.wsdl
2、编写代码调用服务
```java
public class Client {
public static void main(String[] args) {
//1、创建服务视图对象
EnglishChinese englishChinese = new EnglishChinese();
//2、创建服务的实体类
EnglishChineseSoap port = englishChinese.getEnglishChineseSoap();
//3、调用方法
/*
GetMp3
获得朗读MP3字节流
输入参数:Mp3 = Mp3名称; 返回数据:字节数组 Byte[]。
SuggestWord
获得候选词
输入参数:wordKey = 单词; 返回数据:一维字符串数组 String[]。
Translator
中英文双向翻译 DataSet
输入参数:wordKey = 单词; 返回数据:DataSet。(包括全部数据三个DataTable)
TranslatorReferString
中英文双向翻译(相关词条)String()
输入参数:wordKey = 单词; 返回数据:一维字符串数组 String[]。
TranslatorSentenceString
中英文双向翻译(例句)String()
输入参数:wordKey = 单词; 返回数据:一维字符串数组 String[]。
TranslatorString
中英文双向翻译(基本)String()
输入参数:wordKey = 单词; 返回数据:一维字符串数组 String[]。
*/
ArrayOfString hello = port.translatorString("你好");
System.out.println(hello.getString());
System.out.println("=============");
ArrayOfString hello1 = port.translatorString("hello");
System.out.println(hello1.getString());
}
}
```
## 手写符合SOAP协议的请求数据
**目标:** 通过手工的方式来发送满足SOAP协议的数据信息
这样就可以不用生成客户端代码了
### **观察底层发送是数据格式是什么样的?**
(这里以xml为例,也有使用json的)
TCP/IP 监控工具(eclipse使用TCP/IP Monitor,idea使用TunnelliJ)
安装完插件后在idea下Tunnellij下设置 localhost port为8000,redirected to 设置为localhost :8080
type选择HTTP/SOAP

使用client_2的demo调用服务(要改变请求路径为监听的端口)
```java
public class Client {
public static void main(String[] args) throws MalformedURLException {
//URL url = new URL("http://localhost:8080/weatherService?wsdl");
//去请求TunnelliJ,查看请求的数据
URL url = new URL("http://localhost:8000/weatherService?wsdl");
//在
娣卞湷
```
可以看出**最下面的xml就是请求数据**(插件编码有问题!)
### 组装数据,成为这种数据格式并发送
```java
public class Client {
public static void main(String[] args) throws IOException {
// URL
URL url = new URL("http://localhost:8000/weatherService");
//创建一个连接对象,用于向服务器发送http请求信息+获取服务器的响应信息
HttpURLConnection connection = (HttpURLConnection)url.openConnection();
//设置请求信息
connection.setRequestMethod("POST");
connection.setRequestProperty("Content-Type","text/xml; charset=utf-8");
//打开通信
connection.setDoOutput(true);
connection.setDoInput(true);
//拼接符合协议要求的数据格式
String info = buildXML("广州");
//发送请求信息
connection.getOutputStream().write(info.getBytes());
//获取响应的消息
int responseCode = connection.getResponseCode();
if (responseCode == 200) {
//响应状态正常,获取返回的信息
InputStream inputStream = connection.getInputStream();
Scanner sc = new Scanner(inputStream);
while (sc.hasNext()) {
//输出返回信息
System.out.println(sc.nextLine());
//结果:阴天
}
sc.close();
} else {
System.out.println(responseCode);
}
}
private static String buildXML(String cityName) {
return "" +
"" +
"" +
""+cityName+"\t\t\t" +
"" +
"";
}
}
```
## 使用jdk的WebService注解
- **@WebService** 放在接口,放在实现类
- **@WebMethod** 控制方法,可以让方法不对外提供服务
- **@WebResult** 控制发布服务的返回结果名称
- **@WebParam** 控制发布服务的参数名
```java
//基本都要去接口类上进行配置(有些不生效),这里省略接口类代码
@WebService(endpointInterface = "cn.lcdiao.webservice.IWeatherService")
public class IWeatherServiceImpl implements IWeatherService,IOtherService {
//WebResult(name="weatherInfo") 表明返回的参数
//@WebParam(name="cityName") 表明请求的参数名称,默认为arg0..
@Override
public @WebResult(name="weatherInfo") String query(@WebParam(name="cityName") String cityName) {
Random random = new Random();
int n = random.nextInt(3);
String weather = n==2? "晴天":n==1?"阴天":"暴雨";
System.out.println("查询-> "+cityName+" 的天气为:"+weather);
return weather;
}
@Override
public String other() {
return "新的服务!庆祝webservice发布成功!";
}
@Override
@WebMethod(exclude = true)
public String noPublish() {
return "使用注解@WebMethod(exclude = true)不发布出去";
}
@Override
public void test() {
//使用@WebService(endpointInterface = "cn.lcdiao.webservice.IWeatherService")
//指定要发布的哪个接口的方法,不是该接口的方法不发布
//但还需要去该接口类上加上@WebService注解,否则报错
}
}
```
## webservice框架——cxf
### 环境搭建
- 官网下载好文件apache-cxf-3.3.6,配置环境变量
- 测试,在cmd下输入wsdl2java
### 利用CXF发布服务
创建项目,导入文件apache-cxf-3.3.6下lib下的jar包
#### 创建服务接口
```java
@WebService
public interface IWeatherService {
String query(String cityName);
}
```
#### 创建服务实现类
```java
public class WeatherServiceImpl implements IWeatherService {
@Override
public String query(String cityName) {
Random random = new Random();
int n = random.nextInt(3);
String weather = n==2? "晴天":n==1?"阴天":"暴雨";
System.out.println("查询-> "+cityName+" 的天气为:"+weather);
return weather;
}
}
```
#### 发布服务
基于工厂的模式,**三要素**:地址、接口、实现类
```java
public class Client {
public static void main(String[] args) {
JaxWsServerFactoryBean factoryBean = new JaxWsServerFactoryBean();
//1、设置发布的地址
factoryBean.setAddress("http://localhost:8888/weatherService");
//2、设置访问的接口
factoryBean.setServiceClass(IWeatherService.class);
//3、设置服务的实现对象
factoryBean.setServiceBean(new WeatherServiceImpl());
//4、通过工厂创建服务
factoryBean.create();
System.out.println("发布服务成功!");
}
}
```
#### 查看服务的wsdl文档
浏览器访问 http://localhost:8888/weatherService?wsdl
```xml
```
### 利用CXF调用服务
wsdl2java 命令是CXF提供的生成客户端的工具,和wsimport类型,可以根据wsdl生成客户端代码
**wsdl2java常用参数:**
-d,指定输出目录
-p,指定包名,如果不指定该参数,默认包名是wsdl的命名空间的倒序
#### 进入项目src目录下,命令行输出命令
wsdl2java -d . http://localhost:8888/weatherService?wsdl

#### 按照服务的说明书来编程
```java
public class Client {
public static void main(String[] args) throws Exception {
JaxWsProxyFactoryBean proxyFactoryBean = new JaxWsProxyFactoryBean();
//1、设置服务的地址(没有跟?wsdl)
proxyFactoryBean.setAddress("http://localhost:8888/weatherService");
//2、设置服务的接口 ()
proxyFactoryBean.setServiceClass(IWeatherService.class);
//3、通过工厂获取对象
IWeatherService service = (IWeatherService)proxyFactoryBean.create();
//4、调用方法
String q = service.query("广州");
System.out.println(q);
}
}
```
### 利用CXF调用网上的服务
#### 国内手机号码归属地查询
1. **通过服务的服务地址,来生成客户端代码**
**使用命令** : wsdl2java -d . http://ws.webxml.com.cn/WebServices/MobileCodeWS.asmx?WSDL
2. **编写代码调用服务**
```java
public class Client {
public static void main(String[] args) {
JaxWsProxyFactoryBean factoryBean = new JaxWsProxyFactoryBean();
//1、设置服务的地址(没有跟?wsdl)
factoryBean.setAddress("http://ws.webxml.com.cn/WebServices/MobileCodeWS.asmx");
//2、设置服务的接口
factoryBean.setServiceClass(MobileCodeWSSoap.class);
//3、通过工厂获取对象
MobileCodeWSSoap service = factoryBean.create(MobileCodeWSSoap.class);
//4、调用方法
String info = service.getMobileCodeInfo("15876161217", "");
System.out.println(info);
}
}
```
结果:``15876161217:广东 汕头 广东移动全球通卡``
## Spring整合cxf
cxf框架本身依赖spring,从官方下载cxf包种有spring的jar包。
将上边使用的JaxWsServerFactoryBean和JaxWsProxyFactoryBean,改为spring配置方式:
发布服务:使用spring和cxf整合的标签````
客户端调用服务:使用spring和cxf整合的标签````
### 服务端
第一步:maven项目,引入相应的依赖
```xml
webservice
cn.lcdiao
1.0-SNAPSHOT
4.0.0
war
webservice_mvn_cxf_spring
webservice_mvn_cxf_spring
5.2.5.RELEASE
javax
javaee-api
7.0
org.aspectj
aspectjweaver
1.6.8
org.springframework
spring-aop
${spring.version}
org.springframework
spring-context
${spring.version}
org.springframework
spring-context-support
${spring.version}
org.springframework
spring-web
${spring.version}
org.springframework
spring-orm
${spring.version}
org.springframework
spring-beans
${spring.version}
org.springframework
spring-core
${spring.version}
org.apache.cxf
cxf-core
3.2.3
org.apache.cxf
cxf-rt-transports-http
3.2.3
org.apache.cxf
cxf-rt-frontend-jaxws
3.2.3
org.mortbay.jetty
maven-jetty-plugin
6.1.7
8888
30000
${project.build.directory}/${pom.artifactId}-${pom.version}
/
```
第二步:创建SEI接口(WebService EndPoint Interface,是webservice的终端接口,就是WebService服务器端用来处理请求的接口)
```java
@WebService
public interface IDreamService {
String query(String name);
}
```
第三步:创建SEI接口实现类
接口和实现类都要加上**@WebService**注解
```java
@WebService
public class DreamServiceImpl implements IDreamService {
@Override
public String query(String name) {
System.out.println(name + "的梦想是:有钱");
return "有钱";
}
}
```
第四步:配置Spring配置文件 applicationContext.xml
```xml
```
第五步:配置web配置文件 webapp/WEB-INF/web.xml
```xml
contextConfigLocation
classpath:applicationContext.xml
org.springframework.web.context.ContextLoaderListener
CXF
org.apache.cxf.transport.servlet.CXFServlet
1
CXF
/ws/*
```
第六步:启动Tomcat
浏览器输入 http://localhost:8080/ws/DreamService?wsdl 测试结果
PS:本地下载的jar可能部分冲突,一直运行报错,依赖也是配了多次后才成功,不清楚是不是一定要这样配
### 客户端
1、创建项目,在要用的目录下输入目录生成客户端代码
wsdl2java -d . http://localhost:8080/ws/DreamService?wsdl
2、编写代码、配置文件调用服务
- 编写applicationContext.xml文件
```xml
```
- 编写测试类测试
```java
public class DreamServiceTest {
@Test
public void dreamTest() {
ApplicationContext context = new ClassPathXmlApplicationContext("classpath:applicationContext.xml");
IDreamService dreamService = context.getBean(IDreamService.class);
String me = dreamService.query("我");
System.out.println(me);
}
}
```
## Spring+SpringMVC整合cxf调用网上的翻译服务
### 初始环境搭建 (maven)
#### pom.xml
```xml
webservice
cn.lcdiao
1.0-SNAPSHOT
4.0.0
webservice_mvn_ssc_translate
5.2.5.RELEASE
javax
javaee-api
7.0
org.aspectj
aspectjweaver
1.6.8
org.springframework
spring-test
${spring.version}
org.springframework
spring-aop
${spring.version}
org.springframework
spring-context
${spring.version}
org.springframework
spring-context-support
${spring.version}
org.springframework
spring-web
${spring.version}
org.springframework
spring-orm
${spring.version}
org.springframework
spring-beans
${spring.version}
org.springframework
spring-core
${spring.version}
org.springframework
spring-webmvc
${spring.version}
org.apache.cxf
cxf-core
3.2.3
org.apache.cxf
cxf-rt-transports-http
3.2.3
org.apache.cxf
cxf-rt-frontend-jaxws
3.2.3
junit
junit
RELEASE
test
com.fasterxml.jackson.core
jackson-databind
2.10.2
javax.servlet
jstl
1.2
```
#### applicationContext.xml
```xml
```
#### spring-mvc.xml
```xml
```
#### web.xml
```xml
contextConfigLocation
classpath:applicationContext.xml
org.springframework.web.context.ContextLoaderListener
SpringMVC
org.springframework.web.servlet.DispatcherServlet
contextConfigLocation
classpath:spring-*.xml
1
true
SpringMVC
/
encodingFilter
org.springframework.web.filter.CharacterEncodingFilter
encoding
utf-8
forceEncoding
true-8
encodingFilter
/*
```
### 生成客户端代码
wsdl2java -d . D:\GitHub\webservice\webservice_network_client_5\translate.wsdl
### 测试翻译服务
```java
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = "classpath:applicationContext.xml")
public class translateTest {
@Resource
private EnglishChineseSoap translate;
@Test
public void test() {
List happy = translate.translatorString("happy").getString();
happy.forEach(System.out::println);
}
}
```
成功则输出:
```
happy
'hæpi
adj. 快乐的,幸福的
7765.mp3
```
### 编写controller类
```java
@Controller
public class TranslateController {
@Resource
private TranslateService translateService;
@RequestMapping("translate")
@ResponseBody
public String translate(String source) {
return translateService.translate(source);
}
}
```
### 编写service接口
```java
public interface TranslateService {
String translate(String source);
}
```
### 编写service接口实现类
```java
@Service
public class TranslateServiceImpl implements TranslateService {
@Resource
private EnglishChineseSoap translate;
@Override
public String translate(String source) {
List list = translate.translatorString(source).getString();
return list.get(list.size()-2);
}
}
```
### 编写前端页面jsp
```jsp
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
我的翻译
```
## SSM整合CXF
### 服务端
**目标:** 开发基本的查询功能和添加功能
将这些功能以服务的方式发布出去
#### 搭建环境
##### pom.xml
```xml
webservice
cn.lcdiao
1.0-SNAPSHOT
4.0.0
webservice_mvn_ssm_server
5.2.5.RELEASE
3.5.4
2.0.4
mysql
mysql-connector-java
5.1.41
runtime
com.alibaba
druid
1.1.22
org.mybatis
mybatis
${mybatis.version}
org.mybatis
mybatis-spring
${mybatis-spring.version}
javax
javaee-api
7.0
org.aspectj
aspectjweaver
1.6.8
org.springframework
spring-test
${spring.version}
org.springframework
spring-aop
${spring.version}
org.springframework
spring-context
${spring.version}
org.springframework
spring-context-support
${spring.version}
org.springframework
spring-web
${spring.version}
org.springframework
spring-orm
${spring.version}
org.springframework
spring-beans
${spring.version}
org.springframework
spring-core
${spring.version}
org.springframework
spring-webmvc
${spring.version}
org.apache.cxf
cxf-core
3.2.3
org.apache.cxf
cxf-rt-transports-http
3.2.3
org.apache.cxf
cxf-rt-frontend-jaxws
3.2.3
junit
junit
RELEASE
test
com.fasterxml.jackson.core
jackson-databind
2.10.2
javax.servlet
jstl
1.2
```
##### applicationContext.xml
```xml
```
##### spring-mvc.xml
```xml
```
##### jdbc.properties
```properties
jdbc.driver=com.mysql.jdbc.Driver
#数据库地址
jdbc.url=jdbc:mysql://localhost:3306/ssm?useUnicode=true&characterEncoding=utf8
#用户名
jdbc.username=root
#密码
jdbc.password=diao
```
##### web.xml
```xml
contextConfigLocation
classpath:applicationContext.xml
org.springframework.web.context.ContextLoaderListener
SpringMVC
org.springframework.web.servlet.DispatcherServlet
contextConfigLocation
classpath:spring-*.xml
1
true
SpringMVC
/
encodingFilter
org.springframework.web.filter.CharacterEncodingFilter
encoding
utf-8
forceEncoding
true
encodingFilter
/*
DruidWebStatFilter
com.alibaba.druid.support.http.WebStatFilter
exclusions
*.js,*.gif,*.jpg,*.png,*.css,*.ico,/druid/*
DruidWebStatFilter
/*
DruidStatView
com.alibaba.druid.support.http.StatViewServlet
DruidStatView
/druid/*
CXF
org.apache.cxf.transport.servlet.CXFServlet
1
CXF
/ws/*
```
#### 创建实体类
```java
public class User {
private Long id;
private String name;
private Integer age;
public Long getId() {
return id;
}
public void setId(Long id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Integer getAge() {
return age;
}
public void setAge(Integer age) {
this.age = age;
}
}
```
#### 编写mapper接口
```java
public interface UserMapper {
int insert(User record);
int insertSelective(User record);
List list();
User getUser(Long id);
}
```
#### 编写mapper.xml
```xml
insert into user (id, `name`, age)
values (#{id,jdbcType=BIGINT}, #{name,jdbcType=VARCHAR}, #{age,jdbcType=INTEGER})
insert into user
id,
`name`,
age,
#{id,jdbcType=BIGINT},
#{name,jdbcType=VARCHAR},
#{age,jdbcType=INTEGER},
```
#### 编写service接口
```java
@WebService
public interface UserService{
int insert(User record);
int insertSelective(User record);
List list();
User getUser(Long id);
}
```
#### 编写service实现类
```java
@Service
@WebService
public class UserServiceImpl implements UserService{
@Resource
private UserMapper userMapper;
@Override
public int insert(User record) {
return userMapper.insert(record);
}
@Override
public int insertSelective(User record) {
return userMapper.insertSelective(record);
}
@Override
public List list() {
return userMapper.list();
}
@Override
public User getUser(Long id) {
return userMapper.getUser(id);
}
}
```
#### 编写controller
```java
@Controller
public class UserController {
@Resource
private UserService userService;
@RequestMapping("getUser")
@ResponseBody
public User getUser(Long id) {
User user = userService.getUser(id);
System.out.println(user);
return user;
}
@RequestMapping("list")
@ResponseBody
public List list(Long id) {
return userService.list();
}
@RequestMapping(value = "insert",method = RequestMethod.POST)
@ResponseBody
public int insert(@RequestBody User user) {
return userService.insertSelective(user);
}
}
```
#### 测试
浏览器输入 http://localhost:8080/ws/userService?wsdl 有wsdl文档则说明cxf整合成功
浏览器输入 http://localhost:8080/list 能出现数据库的全部user数据,说明ssm整合成功
### 客户端
1、创建项目,在要用的目录下输入目录生成客户端代码
wsdl2java -d . http://localhost:8080/ws/userService?wsdl
2、导入依赖,配置配置文件
3、参照Spring整合cxf,主要就修改下面
```
```
4、写测试类,能运行就说明成功
```java
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = "classpath:applicationContext.xml")
public class WebserviceTest {
@Resource
private UserService wsUserService;
@Test
public void test(){
User user = wsUserService.getUser(1L);
System.out.println(user);
}
}
```
## CXF总结
### 发布服务
1. **JaxWsServerFactoryBean**
2. **设置三要素**
访问路径address
服务的接口
服务的实力对象
spring整合则需要注意标签配置 ` `,一样注意三要素
### 访问服务
1. **根据wsdl生成客户端代码**
2. **JaxWsProxyFactoryBean**
3. **设置二要素**
访问服务的路径
服务提供的接口
spring整合则需要注意标签配置 ``,一样注意二要素