webservice的使用

最新推荐文章于 2024-06-04 10:07:15 发布
最新推荐文章于 2024-06-04 10:07:15 发布
阅读量330 收藏
点赞数 1
分类专栏： SSM项目(java) 文章标签： webservice
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jiemaio/article/details/90369716
版权

JAX-WS JAX-RS JAXM&SAAJ(废弃)

JAX-WS 规范

java api xml-based webservices 早期基于soap的jiava的web服务JAX-RPC (已经被取代),
采用标准得SOAP协议传输 属于w3c标准 SOAP协议基于http的应用层协议 soap协议传输时xml数据
xml是webservice的跨平台的基础,可扩展标记语言,描述数据

*** 服务端入门演示 : ***
服务端依赖

<dependencies> <!-- https://mvnrepository.com/artifact/org.apache.cxf/cxf-rt-frontend-jaxws -->
        <dependency>
            <groupId>org.apache.cxf</groupId>
            <artifactId>cxf-rt-frontend-jaxws</artifactId>
            <version>3.3.0</version>
        </dependency>
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-api</artifactId>
            <version>1.7.25</version>
        </dependency>
        <dependency>
            <groupId>org.apache.cxf</groupId>
            <artifactId>cxf-rt-features-logging</artifactId>
            <version>3.3.0</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
        </dependency>
        <dependency>
            <groupId>org.apache.cxf</groupId>
            <artifactId>cxf-rt-transports-http-jetty</artifactId>
            <version>3.3.0</version>
        </dependency>
    </dependencies>

创建服务端 接口

import javax.jws.WebService;

/**
 * 提供天气的服务
 */
@WebService //表明当前是一个webservice 的服务
public interface Weatherservice {
    //根据城市获取天气信息
    String getWeatherByCityName(String name);
}

实现服务端服务

public class WeatherserviceImpl implements Weatherservice {
    @Override
    public String getWeatherByCityName(String name) {
        //模拟服务 我们这里就写死了
        if("北京".equals(name)){
            return "北京多云" ;
        }else if("上海".equals(name)){
            return "上海晴天" ;
        }else if("深圳".equals(name)){
            return "深圳暴雨" ;
        }else{
            return "未知";
        }
    }
}

对服务端启动 (这里发动) 服务开启后不能停

package com.itheima.test;

import com.itheima.service.WeatherserviceImpl;
import org.apache.cxf.jaxws.JaxWsServerFactoryBean;

/*
    开启服务不能使用单元测试
    服务是需要一直开启的
 */
public class WebserviceServerTest {
    public static void main(String[] args) {
        //1.创建发布的服务的对象
        JaxWsServerFactoryBean factoryBean = new JaxWsServerFactoryBean();
        //2设置服务地址
        factoryBean.setAddress("http://localhost:12345/weahter");
        //3 设置服务的对象
        factoryBean.setServiceBean(new WeatherserviceImpl());
        //the last  发布服务
        factoryBean.create();
        //进行使用  在浏览器中输入 http://localhost:12345/weahter?wsdl    + 说明信息  说明书是给虚拟机看的
        //不加说明信息会出现错误
    }
}

*** 客户端入门演示 : ***
引入客户端依赖

 <dependencies> <!-- https://mvnrepository.com/artifact/org.apache.cxf/cxf-rt-frontend-jaxws -->
        <dependency>
            <groupId>org.apache.cxf</groupId>
            <artifactId>cxf-rt-frontend-jaxws</artifactId>
            <version>3.3.0</version>
        </dependency>
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-api</artifactId>
            <version>1.7.25</version>
        </dependency>
        <dependency>
            <groupId>org.apache.cxf</groupId>
            <artifactId>cxf-rt-features-logging</artifactId>
            <version>3.3.0</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
        </dependency>
        <dependency>
            <groupId>org.apache.cxf</groupId>
            <artifactId>cxf-rt-transports-http-jetty</artifactId>
            <version>3.3.0</version>
        </dependency>
    </dependencies>

//1. 我们靠说明书 创建代码
//我们要测试 谁 测试代码是什么
/*那我们如何创建 代码呢 我们使用jdk 找到我们的jdk的安装目录
在jdk bin目录下找到 wsimport.exe
通过cmd 输入 wsimport 命令
wsimport [options] <WSDL_URI>
-s 指定放置生成的源文件的位置
进入我们的main java 目录下 进行当前cmd
wsimport -s . http://localhost:12345/weahter?wsdl 回车//生成到当前目录 .
*/
生成代码后 测试客户端和服务端连接

package com.itheima.client.test;

import com.itheima.service.Weatherservice;
import org.apache.cxf.jaxws.JaxWsClientFactoryBean;
import org.apache.cxf.jaxws.JaxWsProxyFactoryBean;
import org.junit.Test;

public class jaxms_client01Test {
    @Test //服务器端可以使用测试
    public void test(){
        //1. 我们靠说明书  创建代码
        //我们要测试 谁 测试代码是什么
        /*那我们如何创建 代码呢 我们使用jdk  找到我们的jdk的安装目录
            在jdk bin目录下找到 wsimport.exe
            通过cmd  输入 wsimport 命令
             wsimport [options] <WSDL_URI>
             -s <directory>            指定放置生成的源文件的位置
            进入我们的main java 目录下 进行当前cmd
             wsimport -s . http://localhost:12345/weahter?wsdl   回车//生成到当前目录  .
        */

        //1 创建客户端的代理工厂Bean
        JaxWsProxyFactoryBean proxy = new JaxWsProxyFactoryBean();
        //2.设置说明书的地址
        proxy.setAddress("http://localhost:12345/weahter?wsdl");
        //3.设置客户端需要使用的服务端口类字节码
        proxy.setServiceClass(Weatherservice.class);
        //4.使用proxy创建服务接口的代理对象 使用Object接收
        Object object = proxy.create();
        //5.如果object是service接口的代理实现类我们就可以强转成service接口
        Weatherservice weatherservice = null ;
        if(object instanceof Weatherservice){
            weatherservice = (Weatherservice)object;
        }
        //6.执行service中的方法
        String str = weatherservice.getWeatherByCityName("北京");
        System.out.println(str);


    }
}

mevan web工程中spring和JAX-WS整合使用 (使用tomcat接口)

首先导入服务端依赖

<dependencies>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.0.4.RELEASE</version>
        </dependency> <!-- https://mvnrepository.com/artifact/org.apache.cxf/cxf-rt-frontend-jaxws -->
        <dependency>
            <groupId>org.apache.cxf</groupId>
            <artifactId>cxf-rt-frontend-jaxws</artifactId>
            <version>3.3.0</version>
        </dependency>
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-api</artifactId>
            <version>1.7.25</version>
        </dependency>
        <dependency>
            <groupId>org.apache.cxf</groupId>
            <artifactId>cxf-rt-features-logging</artifactId>
            <version>3.3.0</version>
        </dependency>
        <dependency>
            <groupId>org.apache.cxf</groupId>
            <artifactId>cxf-rt-transports-http-jetty</artifactId>
            <version>3.3.0</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-web</artifactId>
            <version>5.0.4.RELEASE</version>
        </dependency>
    </dependencies>

服务端接口 实现类 使用前面的天气
因为是web工程 所有我们需要在web.xml中配置 jaxws的核心控制器

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://java.sun.com/xml/ns/javaee"
         xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
         version="2.5">
         <!-- 利用监听器 配合配置文件 创建ioc容器 控制反转 -->
    <listener>
        <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
    </listener>
    <context-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>classpath:applicationContext-cxf-server.xml</param-value>
    </context-param>

    <!-- CXF框架的核心控制器:CXFServlet -->
    <servlet>
        <servlet-name>cxf</servlet-name>
        <servlet-class>org.apache.cxf.transport.servlet.CXFServlet</servlet-class>
        <load-on-startup>1</load-on-startup>
    </servlet>
    <servlet-mapping>
        <servlet-name>cxf</servlet-name>
        <url-pattern>/ws/*</url-pattern> <!-- 这里不能使用/*  不是所有地址都需要启动服务 -->
    </servlet-mapping>
</web-app>

配置xml 文件 applicationContext-cxf-server.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:cxf="http://cxf.apache.org/core"
    xmlns:jaxws="http://cxf.apache.org/jaxws"
    xsi:schemaLocation="
        http://www.springframework.org/schema/beans 
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://cxf.apache.org/core
        http://cxf.apache.org/schemas/core.xsd
        http://cxf.apache.org/jaxws
        http://cxf.apache.org/schemas/jaxws.xsd
        ">
	<jaxws:server address="/weather"> <!-- 使用域名 http://localhost:12345/weahter -->
		<jaxws:serviceBean>
		    <bean class="com.itheima.service.WeatherServiceImpl" /> <!-- 设置此处提供服务 -->
		</jaxws:serviceBean>
	</jaxws:server>
</beans>
<!--  此处已经创建了 对象    JaxWsServerFactoryBean jaxWsServerFactoryBean = new JaxWsServerFactoryBean()   
地址使用tomcat的
	xsi:schemaLocation="
        http://www.springframework.org/schema/beans 
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://cxf.apache.org/core
        http://cxf.apache.org/schemas/core.xsd
        http://cxf.apache.org/jaxws
        http://cxf.apache.org/schemas/jaxws.xsd
-->

http://localhost:8080/ws/weather 启动就好
客户端
导入坐标依赖

  <dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.0.4.RELEASE</version>
        </dependency> <!-- https://mvnrepository.com/artifact/org.apache.cxf/cxf-rt-frontend-jaxws -->
        <dependency>
            <groupId>org.apache.cxf</groupId>
            <artifactId>cxf-rt-frontend-jaxws</artifactId>
            <version>3.3.0</version>
        </dependency>
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-api</artifactId>
            <version>1.7.25</version>
        </dependency>
        <dependency>
            <groupId>org.apache.cxf</groupId>
            <artifactId>cxf-rt-features-logging</artifactId>
            <version>3.3.0</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
        </dependency>
        <dependency>
            <groupId>org.apache.cxf</groupId>
            <artifactId>cxf-rt-transports-http-jetty</artifactId>
            <version>3.3.0</version>
        </dependency>
    </dependencies>

applicationContext-cxf-client.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:cxf="http://cxf.apache.org/core"
    xmlns:jaxws="http://cxf.apache.org/jaxws"
    xsi:schemaLocation="
        http://www.springframework.org/schema/beans 
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://cxf.apache.org/core
        http://cxf.apache.org/schemas/core.xsd
        http://cxf.apache.org/jaxws
        http://cxf.apache.org/schemas/jaxws.xsd">

    <jaxws:client id="client"
                  address="http://localhost:8080/ws/weather?wsdl"
                  serviceClass="com.itheima.service.Weatherservice"></jaxws:client>
</beans>

test 测试

package com.itheima.test;

import com.itheima.service.Weatherservice;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class JaxwsClientTest {
    @Test
    public void test() {  //创建代码
        //读取配置文件创建容器  classpath:applicationContext-cxf-client.xml
        ApplicationContext context =
                new ClassPathXmlApplicationContext("classpath:applicationContext-cxf-client.xml");
        //根据bean的id获取对象
        //3.执行方法
        Weatherservice weatherservice =(Weatherservice)context.getBean("client");
        String str = weatherservice.getWeatherByCityName("北京");
        System.out.println(str);

    }
}

JAX-RS 规范 (现在比较火) 此案例为2个模块工程

JAX-RS 针对REST风格制定的一套web服务规范
REST是一种软件架构模式 只是一种风格,rest服务采用了HTTP传输协议

入门案例

引入坐标依赖 服务端 和 客户端 共同依赖

<dependencies>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.apache.cxf</groupId>
            <artifactId>cxf-rt-frontend-jaxrs</artifactId>
            <version>3.0.1</version>
        </dependency>
        <dependency>
            <groupId>org.apache.cxf</groupId>
            <artifactId>cxf-rt-transports-http-jetty</artifactId>
            <version>3.0.1</version>
        </dependency>
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-log4j12</artifactId>
            <version>1.7.12</version>
        </dependency>
        <dependency>
            <groupId>org.apache.cxf</groupId>
            <artifactId>cxf-rt-rs-client</artifactId>
            <version>3.0.1</version>
        </dependency>
        <dependency>
            <groupId>org.apache.cxf</groupId>
            <artifactId>cxf-rt-rs-extension-providers</artifactId>
            <version>3.0.1</version>
        </dependency>
        <dependency>
            <groupId>org.codehaus.jettison</groupId>
            <artifactId>jettison</artifactId>
            <version>1.3.7</version>
        </dependency>
    </dependencies>

service接口

package com.itheima.service;

import com.itheima.domain.User;

import javax.ws.rs.*;
import java.util.List;


@Path("/userService")  //访问这个接口的路径要求
@Produces("*/*")  //生产  可以生产的类型  可以返还任何数据
public interface IUserService {

	@POST  //请求i方式
	@Path("/user")
	@Consumes({ "application/xml", "application/json" })  //消费 可以消费的类型  就是可以接收的2种数据类型
	public void saveUser(User user);

	@PUT
	@Path("/user")
	@Consumes({ "application/xml", "application/json" })
	public void updateUser(User user);

	@GET
	@Path("/user")
	@Produces({ "application/xml", "application/json" })
	public List<User> findAllUsers();

	@GET
	@Path("/user/{id}")
	@Consumes("application/xml")
	@Produces({ "application/xml", "application/json" })
	public User finUserById(@PathParam("id") Integer id);

	@DELETE
	@Path("/user/{id}")
	@Consumes({"application/xml", "application/json"})
	public void deleteUser(@PathParam("id") Integer id);
}

启动服务的spvm

package com.itheima.test;

import com.itheima.service.IUserService;
import com.itheima.service.UserServiceImpl;
import org.apache.cxf.interceptor.LoggingInInterceptor;
import org.apache.cxf.interceptor.LoggingOutInterceptor;
import org.apache.cxf.jaxrs.JAXRSServerFactoryBean;

public class JaxrsserverTest {
    public static void main(String[] args) {
        //创建jaxrs服务对工厂对象
        JAXRSServerFactoryBean jaxrsServerFactoryBean = new JAXRSServerFactoryBean();
        //设置服务地址
        jaxrsServerFactoryBean.setAddress("http://localhost:54321");
        //设置提供服务的类
        jaxrsServerFactoryBean.setServiceBean(new UserServiceImpl());
        //设置日志输入和输出的两个拦截器  //不设置也行
        jaxrsServerFactoryBean.getInInterceptors().add(new LoggingInInterceptor());
        jaxrsServerFactoryBean.getOutInterceptors().add(new LoggingOutInterceptor());
        //the last  启动服务
        jaxrsServerFactoryBean.create();

    }
}

客户端的使用

public class jaxrsClientTest {
    /*
        注意 它和jaxws的区别是  它使用的restful 的url
     */
    @Test  //测试保存方法
    public void test() {
        //使用WebClient创建访问地址    http://localhost:12345
        // /userService  使用谁的方法
        // /user 使用什么方法
        // .type(MediaType.APPLICATION_JSON)
        // MediaType.APPLICATION_XML指定传输数据格式   json  和 xml 可以
        //  .post (user)请求方式  传入参数
        //参数不能是对象 不能是序列化的
        User user = new User();
        user.setId(1);
        user.setUsername("小明");
        user.setCity("北京");
        Object post = WebClient.create("http://localhost:54321/userService/user").type(MediaType.APPLICATION_JSON).post(user);
        System.out.println("post-" + post);
    }
     @Test
    public void test02(){
       WebClient.create("http://localhost:54321/userService/user/1").type(MediaType.APPLICATION_JSON).delete();

    }
}

JAX-RS 和spring 整合

引入共同坐标依赖

<dependencies>
        <dependency>
            <groupId>org.apache.cxf</groupId>
            <artifactId>cxf-rt-frontend-jaxrs</artifactId>
            <version>3.0.1</version>
        </dependency>
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-log4j12</artifactId>
            <version>1.7.12</version>
        </dependency>
        <dependency>
            <groupId>org.apache.cxf</groupId>
            <artifactId>cxf-rt-rs-client</artifactId>
            <version>3.0.1</version>
        </dependency>
        <dependency>
            <groupId>org.apache.cxf</groupId>
            <artifactId>cxf-rt-rs-extension-providers</artifactId>
            <version>3.0.1</version>
        </dependency>
        <dependency>
            <groupId>org.codehaus.jettison</groupId>
            <artifactId>jettison</artifactId>
            <version>1.3.7</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.0.4.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-web</artifactId>
            <version>5.0.4.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
            <version>5.0.4.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
        </dependency>
    </dependencies>

web.xml applicationContext-cxf-rs.xml

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xmlns="http://java.sun.com/xml/ns/javaee"
         xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
         version="2.5">
    <display-name>webservice_05jaxrs_spring</display-name>

    <context-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>classpath:applicationContext-cxf-rs.xml</param-value>
    </context-param>

    <listener>
        <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
    </listener>

    <!-- CXF的核心控制器 -->
    <servlet>
        <servlet-name>cxfServlet</servlet-name>
        <servlet-class>org.apache.cxf.transport.servlet.CXFServlet</servlet-class>
    </servlet>

    <servlet-mapping>
        <servlet-name>cxfServlet</servlet-name>
        <url-pattern>/rs/*</url-pattern>
    </servlet-mapping>
</web-app>

java内部 使用 service03的 com代码
配置文件

<?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:cxf="http://cxf.apache.org/core"
       xmlns:jaxws="http://cxf.apache.org/jaxws"
       xmlns:jaxrs="http://cxf.apache.org/jaxrs"
       xsi:schemaLocation="
        http://www.springframework.org/schema/beans 
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://cxf.apache.org/core
        http://cxf.apache.org/schemas/core.xsd
        http://cxf.apache.org/jaxws
        http://cxf.apache.org/schemas/jaxws.xsd
        http://cxf.apache.org/jaxrs
        http://cxf.apache.org/schemas/jaxrs.xsd
        ">
    <jaxrs:server id="userService" address="/userService"> <!-- 这里配置了路径   那么 注解配置了 就重复了 -->
        <jaxrs:serviceBeans>
            <bean class="com.itheima.service.UserServiceImpl"/>
        </jaxrs:serviceBeans>
        <jaxrs:inInterceptors>
            <bean class="org.apache.cxf.interceptor.LoggingInInterceptor"/>
        </jaxrs:inInterceptors>
        <jaxrs:outInterceptors>
            <bean class="org.apache.cxf.interceptor.LoggingOutInterceptor"/>
        </jaxrs:outInterceptors>
    </jaxrs:server>
</beans>

test 模拟客户端

//服务测试类
public class JaxrsspriingTest {
    @Test
    public void test(){
        //创建客户端
//         User user = WebClient.create("http://localhost:8080/rs/userService/user/1").accept(MediaType.APPLICATION_JSON).get(User.class);
//         User user1 = WebClient.create("http://localhost:8080/rs/userService/user/1").type(MediaType.APPLICATION_JSON).get(User.class
//        System.out.println(user);
        User[] user = WebClient.create("http://localhost:8080/rs/userService/user").type(MediaType.APPLICATION_XML).get(User[].class);
        System.out.println(Arrays.toString(user));
    }
}

JAXM&SAAJ(废弃就不说了)

扶摇的星河
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
WebService是什么
君莫笑丶
03-26 6万+
WebService是什么鬼？全华班 2018-03-23 14:56:35喜欢就点击上面蓝色字，更多精彩！导读 ｜ 精选一、什么是Web Service1. 什么是Web Service呢？从表面上看，WebService就是一个应用程序，它向外界暴露出一个能够通过Web进行调用的API。这就是说，你能够用编程的方法通过Web调用来实现某个功能的应用程序。从深层次上看，Web Service是一...
webservice接口与HTTP接口学习笔记一、webservice 的概念
m0_70618214的博客
02-03 5081
Web是使应用程序可以与平台和编程语言无关的方式进行相互通信的一项技术。Web 服务是一个软件接口，它描述了一组可以在网络上通过标准化的 XML 消息传递访问的操作。它使用基于 XML 语言的协议来描述要执行的操作或者要与另一个 Web 服务交换的数据。一组以这种方式交互的 Web 服务在面向服务的体系结构（Service-Oriented Architecture，SOA）中定义了特殊的 Web 服务应用程序。 简单的说WebService是一个SOA（面向服务的编程）的架构，它是不依赖于语言，不依赖
webService入门到精通
最新发布
qq_52231508的博客
06-04 864
webservice
SpringBoot 整合WebService详解
Java的一只小实习生的博客
04-24 9348
WebService服务端是以远程接口为主的，在Java实现的WebService技术里主要依靠CXF开发框架，而这个CXF开发框架可以直接将接口发布成WebService。RS基于Restful风格，WS基于SOAP的XML协议RS比WS传输的数据更少，效率更高WS只能传输XML数据，RS可以传输XML，也可以传输JSON参考:此处讲解JAX-WS。
springboot开发webservice服务端，发布多个webservice服务案例（带你玩转webservice）
Brave_heart4pzj的博客
09-05 5896
webservice
Webservice
woaini886353的博客
04-26 5517
★. WebService，顾名思义就是基于Web的服务。它使用Web(HTTP)方式，接收和响应外部系统的某种请求。从而实现远程调用. 我们可以调用互联网上查询天气信息Web服务，然后将它嵌入到我们的程序(C/S或B/S程序)当中来，当用户从我们的网点看到天气信息时，他会认为我们为他提供了很多的信息服务，但其实我们什么也没有做，只是简单调用了一下服务器上的一段代码而已。 学习WebService可以将你的服务(一段代码)发布到互联网上让别人去调用,也可以调用别人机器上发布的WebService,就像使
WebService使用
04-03
本教程将深入探讨WebService的接口详细使用，并提供实例参考，帮助你更好地理解和应用这一技术。 一、WebService基本概念 1. WSDL（Web Service Description Language）：WebService的定义语言，描述了服务的位置、...
webservice使用教程
06-26
webservice使用教程，详细介绍了webservice的使用方法，并且有实例代码
SOAPUI测试WEBSERVICE使用手册
05-16
SOAPUI测试WEBSERVICE使用手册
webService使用实例
04-10
在本实例中，我们将探讨如何使用C#语言来调用WebService，具体涉及天气预报查询和火车时刻表查询的应用场景。 首先，让我们理解WebService的工作原理。WebService基于简单对象访问协议（SOAP），它通过HTTP协议传递...
使用Http post的方式调用webservice
07-07
如果WebService使用SOAP协议，你需要构造SOAP请求消息并设置适当的HTTP头。SOAP消息通常包含一个XML结构，包括SOAP Envelope、Header和Body。使用如SAAJ（SOAP with Attachments API for Java）库可以更方便地处理...
WebService使用参考手册，非常适合初学者
05-18
WebService客户端和服务器部署全步骤，作为客户端和服务端的详细步骤，有重点，有案例代码，非常适合初学者学习和参考，对webService的理解和使用有很大的帮助！
【十二】springboot整合WebService
热门推荐
weixin_56995925的博客
09-22 1万+
springboot整合WebService
SpringBoot整合WebService 【客户端、服务端】
qq_46220373的博客
04-03 761
在线的wsdl：http://127.0.0.1:9090/xx/user?
什么是web service？
xiaoweids的博客
06-10 1900
转自：微点阅读 https://www.weidianyuedu.com1，什么是 Web Service ? Web Service 就是一个网络组件（一个可以通过网络访问的程序）。 它有一个或多个端口（Port），这些端口用于接收客户端的请求，并返回响应 请求和响应的 都是一种基于XML的消息。 不过这种消息遵循特定的格式（SOAP ）。 2，怎样调用 Web Service？ 可能这样说不太准确，应该是“怎样调用Web Service中定义的操作 ” 每个Web Service 都有一
用Springboot搭建webService服务
weixin_43952429的博客
07-31 608
概述 WebService简单概述就是用http发送接收xml数据，但这个xml得遵守系统的规范。这个规范就是WSDL（Web服务描述语言，Web Services Description Language），在WebService中传输的xml有一个正式的名称叫Soap（简单对象访问协议 Simple Object Access Protocol）。 代码实现 首先，准备一个wsdl 文档 wsdl 文档包含五个标准元素：types, message, portType, binding and se
WebService使用详解
aliyacl的博客
03-13 6633
WebService其实就是远程调用服务，分为服务端开发和客户端开发。看上去很厉害的样子，其实使用起来很简单。下面介绍不使用框架和使用CXF框架两种使用WebService的方法。 一、不使用框架的WebService 1、服务端代码，生成供客户端使用的方法 /* @WebService:是一个注解，用在类上指定将此类发布成一个ws */ @WebService publ...
SpringBoot整合WebService（wsdd）
z1696637434的博客
03-19 1624
在SpringBoot中整合WebService（wsdd），WebService需要依赖Servlet并且需要Tomcat才能运行。
springboot+cxf+logback报文日志日志记录（已实现将不同接口写入不同日志）
a116475939的专栏
03-14 3847
0. 问题来源 https://blog.csdn.net/a116475939/article/details/88526218 继上一篇博客之后，已经可以在发布cxf接口，并且记录日志报文到日志文件中。 但是所有接口的日志都在一个文件中，这样很不合理，不便于追溯问题查找日志。 所以今天则要实现这个功能。 1. 问题思考 @Bean(name = Bus.DEFAULT_BUS_ID) ...
webservice使用
09-01
WebService是一种基于Web的服务通信协议，它允许不同的应用程序在网络上进行通信和交互。使用WebService，您可以将应用程序的功能暴露为可由其他应用程序调用的服务。 要使用WebService，您需要以下步骤： 1. 定义WebService：首先，您需要定义您的WebService，即确定要提供的功能和操作。您可以使用不同的技术（如SOAP，REST等）来定义和实现WebService。 2. 创建WebService客户端：要使用一个WebService，您需要创建一个客户端应用程序，以便能够调用该服务。客户端可以是任何支持Web服务协议的应用程序或平台，如Java，.NET等。 3. 生成代理类：在客户端中，您需要生成一个代理类来与WebService进行交互。代理类是一个自动生成的类，它包含了与WebService通信所需的方法和数据结构。 4. 调用WebService：使用生成的代理类，您可以在客户端应用程序中调用WebService的方法。这些方法可以通过简单的函数调用来使用，就像调用本地函数一样。 5. 处理响应：当调用WebService方法时，您将获得一个响应对象。您需要根据WebService的返回值来处理这个响应，并采取适当的操作。 总之，使用WebService可以方便地实现不同应用程序之间的通信和数据交换。它提供了一种标准化的方式来构建分布式系统，并允许不同平台和技术之间的互操作性。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

扶摇的星河

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值