使用axis1+spring+hibernate搭建webservice框架

最新推荐文章于 2022-09-16 08:56:38 发布
最新推荐文章于 2022-09-16 08:56:38 发布
阅读量473 收藏
点赞数
分类专栏： 代码生成工具

最代码官方 2014-03-06 14:52:57
待使用axis1+spring+hibernate搭建webservice框架

写在前面的话：

       网上的教程大多都是使用wsdl2java工具构建webservice。本文则直接采用编辑server-config.wsdd来发布webservice，相比而言，可以比较快速的部署一个项目，适应工作需要。

   本教程模拟提供用户接口用于和别的系统结合，主要功能包括接受用户的增删改查。

一数据库创建
    创建数据库webservice

，创建用户表user

，用户表内容如下：

view source print ?
1CREATE TABLE ` user ` (
2 `uid` int ( ) unsigned NOT NULL auto_increment,
3 `name` varchar ( ) NOT NULL default '' ,
4 `password` varchar ( ) NOT NULL default '' ,
5 `nickname` varchar ( ) NOT NULL default '' ,
6 PRIMARY KEY (`uid`)
7) ENGINE=InnoDB DEFAULT CHARSET= gbk;

（您也可以直接使用附件中的sql文件创建数据库）

 

二新建web项目，搭建spring+hibernate框架。

1）新建用户模型，User类，如下：

view source print ?
01package com.zuidaima.model;
02 
03public class User {
04    /*
05     * 用户属性，分别对应user表
06     */
07    /*
08     * 用户id
09     */
10    private Integer uid;
11    /*
12     * 用户名
13     */
14    private String name;
15    /*
16     * 密码
17     */
18    private String password;
19    /*
20     * 用户昵称
21     */
22    private String nickname;
23 
24    /*
25     * 必须提供一不带参数的构造方法，以供hibernate初始化User
26     */
27    public User() {
28 
29    }
30 
31    /*
32     * 使用参数构建User
33     */
34    public User(String name, String password, String nickname) {
35        this.name = name;
36        this.password = password;
37        this.nickname = nickname;
38    }
39 
40    public Integer getUid() {
41        return uid;
42    }
43 
44    public void setUid(Integer uid) {
45        this.uid = uid;
46    }
47 
48    public String getName() {
49        return name;
50    }
51 
52    public void setName(String name) {
53        this.name = name;
54    }
55 
56    public String getPassword() {
57        return password;
58    }
59 
60    public void setPassword(String password) {
61        this.password = password;
62    }
63 
64    public String getNickname() {
65        return nickname;
66    }
67 
68    public void setNickname(String nickname) {
69        this.nickname = nickname;
70    }
71}

另外user的配置文件User.hbm.xml如下：

view source print ?
01<?xml version="1.0" encoding="UTF-8"?>
02<!DOCTYPE hibernate-mapping PUBLIC
03    "-//Hibernate/Hibernate Mapping DTD 2.0//EN"
04    "http://hibernate.sourceforge.net/hibernate-mapping-2.0.dtd" >
05 
06<hibernate-mapping>
07    <class name="com.zuidaima.model.User" table="user">
08        <id name="uid" type="java.lang.Integer" column="UID">
09            <generator class="native"></generator>
10        </id>
11        <property name="name" type="java.lang.String" column="NAME"
12            length="45" insert="true" update="true" />
13        <property name="password" type="java.lang.String" column="PASSWORD"
14            length="45" insert="true" update="true" />
15        <property name="nickname" type="java.lang.String" column="NICKNAME"
16            length="45" insert="true" update="true" />
17    </class>
18</hibernate-mapping>

2）新建DAO,UserDAO类，如下：

view source print ?
01package com.zuidaima.dao;
02 
03import java.util.List;
04 
05import org.springframework.orm.hibernate.support.HibernateDaoSupport;
06import com.zuidaima.model.User;
07 
08public class UserDAO extends HibernateDaoSupport {
09    public User getUser(int uid) {
10        return (User) getHibernateTemplate().get(User.class, new Integer(uid));
11    }
12 
13    /**
14     * 添加用户
15     *
16     * @param user
17     */
18    public void saveUser(User user) {
19        getHibernateTemplate().save(user);
20    }
21 
22    /**
23     * 删除用户
24     *
25     * @param uid
26     */
27    public void deleteUser(int uid) {
28        StringBuffer strBuf = new StringBuffer();
29        strBuf.append("from User as u where u.uid=");
30        strBuf.append(uid);
31        getHibernateTemplate().delete(strBuf.toString());
32    }
33 
34    /**
35     * 更新用户
36     *
37     * @param user
38     */
39    public void updateUser(User user) {
40        getHibernateTemplate().saveOrUpdate(user);
41    }
42 
43    /**
44     * 根据用户名查找用户
45     *
46     * @param name
47     * @return user or null
48     */
49    /*
50     * return null if can't find
51     */
52    public User getUserByName(String name) {
53        StringBuffer strBuf = new StringBuffer();
54        strBuf.append("select u from User as u where u.name='");
55        strBuf.append(name);
56        strBuf.append("'");
57        List tempList = getHibernateTemplate().find(strBuf.toString());
58        if (tempList != null && tempList.size() > 0) {
59            return (User) tempList.get(0);
60        } else {
61            return null;
62        }
63    }
64 
65    /**
66     * 用户列表
67     *
68     * @return user List
69     */
70    public List listUser() {
71        StringBuffer strBuf = new StringBuffer();
72        strBuf.append("select u from User as u ");
73        return getHibernateTemplate().find(strBuf.toString());
74    }
75 
76}

3）新建管理层，UserManager接口和其实现UserManagerImpl。

UserManager接口：

view source print ?
01package org.yoo.service;
02 
03 import java.util.List;
04 
05 import org.yoo.model.User;
06 
07 public interface UserManager {
08  
09 /**
10 * 根据uid查找用户
11 * @param uid
12 * @return user
13 */
14 public User getUserByUid( int uid);
15 /**
16 * 增加用户
17 * @param user
18 */
19 public void saveUser(User user);
20 /**
21 * 删除用户
22 * @param uid
23 */
24 public void deleteUser( int uid);
25  
26 /**
27 * 更新用户信息
28 * @param user
29 */
30 public void updateUser(User user);
31  
32 /**
33 * 根据用户名查找用户
34 * @param name
35 * @return user
36 */
37 public User getUserByName(String name);
38  
39 /**
40 * 用户列表
41 * @return user List
42 */
43 public List listUser();
44}

UserManagerImpl如下：

view source print ?
01package com.zuidaima.service.impl;
02 
03import java.util.List;
04 
05import com.zuidaima.dao.UserDAO;
06import com.zuidaima.model.User;
07import com.zuidaima.service.UserManager;
08 
09public class UserManagerImpl implements UserManager {
10    private UserDAO userDAO = null;
11 
12    public void deleteUser(int uid) {
13        userDAO.deleteUser(uid);
14 
15    }
16 
17    public User getUserByName(String name) {
18 
19        return userDAO.getUserByName(name);
20    }
21 
22    public User getUserByUid(int uid) {
23 
24        return userDAO.getUser(uid);
25    }
26 
27    public List listUser() {
28 
29        return userDAO.listUser();
30    }
31 
32    public void saveUser(User user) {
33        userDAO.saveUser(user);
34 
35    }
36 
37    public void updateUser(User user) {
38        userDAO.updateUser(user);
39 
40    }
41 
42    /*
43     * Ioc By Spring
44     */
45    public void setUserDAO(UserDAO userDAO) {
46        this.userDAO = userDAO;
47    }
48 
49}

 

4）配置xml文件。

Spring-config.xml

view source print ?
01<?xml version="1.0" encoding="UTF-8"?>
02<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN"
03    "http://www.springframework.org/dtd/spring-beans.dtd">
04 
05<beans>
06 
07    <!-- ==DATA SOURCE======================================== -->
08    <!-- Data Source for MYSQL -->
09    <bean id="dataSource_MYSQL"
10        class="org.springframework.jdbc.datasource.DriverManagerDataSource">
11        <property name="driverClassName">
12            <value>org.gjt.mm.mysql.Driver</value>
13        </property>
14        <property name="url">
15            <value>jdbc:mysql://127.0.0.1:3306/webservice?useUnicode=true&amp;characterEncoding=GBK</value>
16        </property>
17        <property name="username">
18            <value>root</value>
19        </property>
20        <property name="password">
21            <value>111111</value>
22        </property>
23    </bean>
24 
25    <!--==SESSION FACTORY===================================== -->
26    <!-- Hibernate SessionFactory -->
27    <bean id="sessionFactory"
28        class="org.springframework.orm.hibernate.LocalSessionFactoryBean">
29        <property name="dataSource">
30            <ref local="dataSource_MYSQL" />
31        </property>
32 
33        <property name="mappingResources">
34            <list>
35                <value>com/zuidaima/model/mysql/User.hbm.xml</value>
36            </list>
37        </property>
38 
39        <property name="hibernateProperties">
40            <props>
41                <!--sql dialect for MYSQL -->
42                <prop key="hibernate.dialect">
43                    net.sf.hibernate.dialect.MySQLDialect
44                </prop>
45                <prop key="connection.pool.size">10</prop>
46                <prop key="statement_cache.size">25</prop>
47                <prop key="jdbc.fetch_size">50</prop>
48                <prop key="jdbc.batch_size">30</prop>
49                <prop key="hibernate.show_sql">true</prop>
50                <prop key="cglib.use_reflection_optimizer">true</prop>
51            </props>
52        </property>
53    </bean>
54    <!--==TRANSACTION======================================= -->
55    <!-- Transaction manager for a single Hibernate SessionFactory -->
56    <bean id="transactionManager"
57        class="org.springframework.orm.hibernate.HibernateTransactionManager">
58        <property name="sessionFactory">
59            <ref local="sessionFactory" />
60        </property>
61    </bean>
62</beans>

Spring-dao.xml

view source print ?
01<?xml version="1.0" encoding="UTF-8"?>
02<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN"
03    "http://www.springframework.org/dtd/spring-beans.dtd">
04<beans>
05    <bean id="userDAO" class="com.zuidaima.dao.UserDAO">
06        <property name="sessionFactory">
07            <ref bean="sessionFactory" />
08        </property>
09    </bean>
10</beans>

Spring-service.xml

view source print ?
01<?xml version="1.0" encoding="UTF-8"?>
02<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN"
03    "http://www.springframework.org/dtd/spring-beans.dtd">
04 
05<beans>
06    <bean id="userManager" class="com.zuidaima.service.impl.UserManagerImpl">
07        <property name="userDAO">
08            <ref bean="userDAO" />
09        </property>
10    </bean>
11</beans>

(您也可以将这三个文件合并在一个文件中，我将它们分开是觉得便于管理。另外如果这部分的配置您不明白，请先查看有关spring+hibernate的相关文章)

5）构建bean工厂

在此只前，都是和利用spring+hibernate搭建web项目一致，这一步开始要有些不同了。由于axis1不支持spring，所以无法直接创建spring的容器，我们需要自己构建bean工厂。

创建BeanxmlFactoryl类，如下：

view source print ?
01package com.zuidaima.beanfactory;
02 
03import org.springframework.context.ApplicationContext;
04import org.springframework.context.support.ClassPathXmlApplicationContext;
05import com.zuidaima.service.UserManager;
06 
07/**
08 * 单列模式的bean工厂类 SpringBean Factory
09 *
10 * @author yoo
11 *
12 */
13public class BeanxmlFactory {
14    private static BeanxmlFactory beanxmlfactory = null;
15    private UserManager userManager = null;
16 
17    /*
18     * 私有的构造方法
19     */
20    private BeanxmlFactory() {
21        /**
22         * 读取spring+hibernate的配置文件
23         */
24        String[] configs = { "/spring-config.xml", "/spring-dao.xml",
25                "/spring-service.xml" };
26        ApplicationContext context = new ClassPathXmlApplicationContext(configs);
27        /*
28         * 获取制定的bean
29         */
30        this.userManager = (UserManager) context.getBean("userManager");
31    }
32 
33    /*
34     *
35     */
36    public synchronized static BeanxmlFactory getInstance() {
37        if (beanxmlfactory == null) {
38            beanxmlfactory = new BeanxmlFactory();
39        }
40        return beanxmlfactory;
41    }
42 
43    public UserManager getUserManager() {
44        return userManager;
45    }
46 
47}

到此我们的web项目已经搭建完成了，余下的事情就是构建webservice的服务了。

三构建service

1）新建一个类，我们命名它为UserService。该类利用由Spring提供的UserManager Bean，生产用户的增加和删除服务，如下：

view source print ?
01package com.zuidaima.webservice;
02 
03import java.util.ArrayList;
04import java.util.List;
05 
06import org.apache.commons.logging.Log;
07import org.apache.commons.logging.LogFactory;
08import com.zuidaima.beanfactory.BeanxmlFactory;
09import com.zuidaima.model.User;
10import com.zuidaima.service.UserManager;
11 
12public class UserService {
13    private static Log log = LogFactory.getLog(UserService.class);
14    private UserManager userManager = null;
15 
16    /*
17     * 获取spring提供的userManager bean
18     */
19    public UserService() {
20        this.userManager = BeanxmlFactory.getInstance().getUserManager();
21    }
22 
23    /**
24     * 使用信息创建用户
25     *
26     * @param name
27     *            用户名
28     * @param password
29     *            密码
30     * @param nickname
31     *            昵称
32     * @return user‘uid or error code 0 用户名已存在 -1 创建用户出错
33     */
34    public int createUserByUserInfo(String name, String password,
35            String nickname) {
36        log.info("come in createUser method");
37        int resultCode = 0;
38        try {
39            User userTemp = userManager.getUserByName(name);
40            if (userTemp == null) {
41                User user = new User(name, password, nickname);
42                userManager.saveUser(user);
43                resultCode = user.getUid().intValue();
44            } else {
45                resultCode = 0;
46            }
47        } catch (Exception e) {
48            log.error("createUser have error:", e);
49            resultCode = -1;
50        }
51        return resultCode;
52    }
53 
54    /**
55     * 删除用户
56     *
57     * @param uid
58     * @return boolean value
59     */
60    public boolean deleteUser(int uid) {
61        log.info("come in deleteUser method");
62        boolean resultCode = true;
63        try {
64            userManager.deleteUser(uid);
65        } catch (Exception e) {
66            log.error("deleteUser have error:", e);
67            resultCode = false;
68        }
69        return resultCode;
70    }
71 
72}

2）添加axis1所需要的jar包。

复制axis-1_4"lib下所有的包到你的项目lib下。

(可以到apache网站上下载axis-1——4，或者在本文附件中获取)

3）Ok，最重要的一步，也是最奇妙的一步来了，构建server-config.wsdd，即利用axis1搭建webservice服务的描述文件。在web.xml同目录下，新建一xml文件，命名为server-config.wsdd文件类容如下：

view source print ?
01<?xml version="1.0" encoding="UTF-8"?>
02<deployment xmlns="http://xml.apache.org/axis/wsdd/"
03    xmlns:java="http://xml.apache.org/axis/wsdd/providers/java">
04    <globalConfiguration>
05        <parameter name="wsdlTargetNamespace" value="http://model.yoo.org" />
06        <parameter name="adminPassword" value="admin" />
07        <parameter name="attachments.implementation"
08            value="org.apache.axis.attachments.AttachmentsImpl" />
09        <parameter name="sendXsiTypes" value="true" />
10        <parameter name="sendMultiRefs" value="true" />
11        <parameter name="sendXMLDeclaration" value="true" />
12        <parameter name="axis.sendMinimizedElements" value="true" />
13        <requestFlow>
14            <handler type="java:org.apache.axis.handlers.JWSHandler">
15                <parameter name="scope" value="session" />
16            </handler>
17            <handler type="java:org.apache.axis.handlers.JWSHandler">
18                <parameter name="scope" value="request" />
19                <parameter name="extension" value=".jwr" />
20            </handler>
21        </requestFlow>
22    </globalConfiguration>
23    <handler name="LocalResponder"
24        type="java:org.apache.axis.transport.local.LocalResponder" />
25    <handler name="URLMapper" type="java:org.apache.axis.handlers.http.URLMapper" />
26    <handler name="Authenticate"
27        type="java:org.apache.axis.handlers.SimpleAuthenticationHandler" />
28    <!--服务的名称 -->
29    <service name="UserService" provider="java:RPC">
30        <parameter name="scope" value="Request" />
31        <!--所有的方法都可以访问 -->
32        <parameter name="allowedMethods" value="*" />
33        <!-- 服务指向的类 -->
34        <parameter name="className" value="com.zuidaima.webservice.UserService" />
35    </service>
36    <!-- other service -->
37    <!-- 可以部署多个服务 -->
38    <!-- <service name="balabala" provider="java:RPC"> <parameter name="allowedMethods"
39        value="*"/> <parameter name="scope" value="Request"/> <parameter name="className"
40        value="balabala"/> </service> -->
41    <!-- axis1 -->
42    <service name="AdminService" provider="java:MSG">
43        <parameter name="allowedMethods" value="AdminService" />
44        <parameter name="enableRemoteAdmin" value="false" />
45        <parameter name="className" value="org.apache.axis.utils.Admin" />
46        <namespace>http://xml.apache.org/axis/wsdd/</namespace>
47    </service>
48    <service name="Version" provider="java:RPC">
49        <parameter name="allowedMethods" value="getVersion" />
50        <parameter name="className" value="org.apache.axis.Version" />
51    </service>
52    <transport name="http">
53        <requestFlow>
54            <handler type="URLMapper" />
55            <handler type="java:org.apache.axis.handlers.http.HTTPAuthHandler" />
56        </requestFlow>
57    </transport>
58    <transport name="local">
59        <responseFlow>
60            <handler type="LocalResponder" />
61        </responseFlow>
62    </transport>
63</deployment>

4）最后一步，需要使用tomcat支持我们搭建的webservice。编辑web.xml，编辑后的文件内容如下：

view source print ?
01<?xml version="1.0" encoding="ISO-8859-1"?>
02 
03<!DOCTYPE web-app PUBLIC "-//Sun Microsystems, Inc.//DTD Web
04Application 2.3//EN" "http://java.sun.com/dtd/web-app_2_3.dtd">
05 
06<web-app>
07    <display-name>aoservice-axis1</display-name>
08 
09    <listener>
10        <listener-class>org.apache.axis.transport.http.AxisHTTPSessionListener</listener-class>
11    </listener>
12 
13    <servlet>
14        <servlet-name>AxisServlet</servlet-name>
15        <display-name>Apache-Axis Servlet</display-name>
16        <servlet-class>
17            org.apache.axis.transport.http.AxisServlet
18        </servlet-class>
19    </servlet>
20 
21    <servlet>
22        <servlet-name>AdminServlet</servlet-name>
23        <display-name>Axis Admin Servlet</display-name>
24        <servlet-class>
25            org.apache.axis.transport.http.AdminServlet
26        </servlet-class>
27        <load-on-startup>100</load-on-startup>
28    </servlet>
29 
30    <servlet>
31        <servlet-name>SOAPMonitorService</servlet-name>
32        <display-name>SOAPMonitorService</display-name>
33        <servlet-class>
34            org.apache.axis.monitor.SOAPMonitorService
35        </servlet-class>
36        <init-param>
37            <param-name>SOAPMonitorPort</param-name>
38            <param-value>5001</param-value>
39        </init-param>
40        <load-on-startup>100</load-on-startup>
41    </servlet>
42 
43    <servlet-mapping>
44        <servlet-name>AxisServlet</servlet-name>
45        <url-pattern>/servlet/AxisServlet</url-pattern>
46    </servlet-mapping>
47 
48    <servlet-mapping>
49        <servlet-name>AxisServlet</servlet-name>
50        <url-pattern>*.jws</url-pattern>
51    </servlet-mapping>
52 
53    <servlet-mapping>
54        <servlet-name>AxisServlet</servlet-name>
55        <url-pattern>/services/*</url-pattern>
56    </servlet-mapping>
57 
58    <servlet-mapping>
59        <servlet-name>SOAPMonitorService</servlet-name>
60        <url-pattern>/SOAPMonitor</url-pattern>
61    </servlet-mapping>
62 
63    <!-- uncomment this if you want the admin servlet -->
64    <!-- <servlet-mapping> <servlet-name>AdminServlet</servlet-name> <url-pattern>/servlet/AdminServlet</url-pattern>
65        </servlet-mapping> -->
66 
67    <session-config>
68        <!-- Default to 5 minute session timeouts -->
69        <session-timeout>5</session-timeout>
70    </session-config>
71 
72    <!-- currently the W3C havent settled on a media type for WSDL; http://www.w3.org/TR/2003/WD-wsdl12-20030303/#ietf-draft
73        for now we go with the basic 'it's XML' response -->
74    <mime-mapping>
75        <extension>wsdl</extension>
76        <mime-type>text/xml</mime-type>
77    </mime-mapping>
78 
79 
80    <mime-mapping>
81        <extension>xsd</extension>
82        <mime-type>text/xml</mime-type>
83    </mime-mapping>
84 
85    <welcome-file-list id="WelcomeFileList">
86        <welcome-file>index.jsp</welcome-file>
87        <welcome-file>index.html</welcome-file>
88        <welcome-file>index.jws</welcome-file>
89    </welcome-file-list>
90 
91</web-app>

到此，我们可以歇口气啦，我们已经搭建好了一个简单的webservice了。

项目截图：

该项目由于我对webservice不熟悉，所以只是把文档涉及到的代码搭建成了maven工程，花了不少时间也没验证通过，大家谁有能力的帮忙验证下吧。



1个评论 0个牛币 标签： axis 框架搭建 webservice spring hibernate 话题： Web开发 WebService
南华
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
详解hibernate与webservice结合使用
08-29
详解hibernate与webservice结合使用
axis2+spring+hibernate Webservice
07-20
标题 "axis2+spring+hibernate Webservice" 指出的是一个基于Java的开源项目，它结合了三个关键的技术框架：Axis2、Spring和Hibernate。这些技术都是企业级应用开发中的重要组件，用于构建高效、灵活且可扩展的服务...
使用axis1+spring+hibernate搭建webservice框架(二)
zl的博客
06-08 536
三构建service 1）新建一个类，我们命名它为UserService。该类利用由Spring提供的UserManager Bean，生产用户的增加和删除服务，如下： 01 package com.zuidaima.webservice; 02   03 import
使用Axis开发Web Service程序 整合 spring
dainiao01的专栏
05-05 2244
使用Axis开发Web Service程序 整合 spring其中 项目 需要 必要的  axis 包 和 spring 包　　1、编写服务端程序 接口package com.xino.iservice;public interface ISayHello {    //接口    public String getName(String name);}编写接口的实现：package com.xi
Axis2+hibernate 编写webservice（主要部分代码）
xuyongzhe628的专栏
02-21 588
首先到官网下载最新的lib库 http://axis.apache.org/axis2/java/core/release-notes/1.7.4.html 这边用的1.7的库，官方教程 1.新建一个动态web项目，将官方的lib拷贝到项目中webcontent/WEB-INF/lib下，没有lib文件就新建lib文件夹。 2.将axis2的moudles文件拷贝到webContent/WEB
axis2+spring2.5整合（webservice）
03-11
当我们谈论“Axis2+Spring2.5整合（Web服务）”时，我们指的是将Apache Axis2和Spring框架结合在一起，以便更高效地开发和管理Web服务。 Apache Axis2是Apache软件基金会开发的一个Web服务引擎，它提供了SOAP消息...
axis2+Spring提供WebService服务
03-09
Axis2和Spring框架的结合提供了一种高效且灵活的方式来创建和管理WebService。让我们深入了解一下这两个技术以及它们如何协同工作。 首先，Apache Axis2是Java平台上一个成熟的Web服务引擎，专门用于处理SOAP消息。...
jsf+spring+hibernate+Axis2开发案例
01-19
本案例"jsf+spring+hibernate+Axis2开发案例"旨在演示如何整合这四个核心技术来创建一个完整的Web应用程序。 首先，`JSF (JavaServer Faces)`是一种用于构建用户界面的MVC（Model-View-Controller）框架，它简化了...
axis2+hibernate+Spring测试案例
01-16
在hibernate spring项目基础上通过aixs2-1.4.1把程序发布成webService，包括aixs2以对象数组和AXIOM方式处理map，list的程序代码；和aixs2-1.4-1的jar包
Springboot，axis1.4的demo
03-22
Springboot集成axis1.4的demo，亲测好用，大家可以试试
spring集成axis发布webservice源码
09-27
spring集成axis发布webservice源码 spring集成axis发布webservice源码 spring集成axis发布webservice源码 spring集成axis发布webservice源码
springboot+axis1.4
05-22
springboot 集成axis1.4的webservice，该为maven的工程
axis1.4 spring3.0 集成 实现 web service
06-13
axis1.4 spring3.0 集成 实现 web service 服务端， axis1.4 客户端认证，授权，访问日志记录，集成spring 解决 PHP 调用web service 无法认证，和解析soap 模板
springboot集成axis2-1.7.9实例
01-14
springboot集成axis2-1.7.9部署和调用实例
Eclipse下搭建Hibernate，并将其发布成WebService
山月神话
04-22 3780
此篇文章是我在搭建Hibernate WebService時學到的一些知識。 1> 新建名為HibernateWebService的Web Project2> 選中此項目點擊右鍵--MyEclipse->Add Hibernate Capabilities...彈出Hibernate Support for MyEclipse對話框3> 選中添加到工程的包Core和Advanced
WebService配置Hibernate过程（MyEclipse）图文教程
水寒
11-03 1158
1.给WebService添加Hibernate组件 2.选择Hibernate版本，并引人jar，指定jar的存放位置 3.生成新的Hibernate配置文件 4.选择数据库链接（注意，这里的数据库链接是在别的地方配置的，具体见http://blog.csdn.net/yuanhong55/article/details/14108027）
Axis1.4+Spring的webservice实现
yzd
09-27 99
最近用到了cxf的webservice组件，为外部系统提供的接口访问，对接过程中发现外部系统发过来的接口参数，在我这边竟然都是null，于是抓包分析，发现cxf产生的soap报文的格式是这样的： Java代码   &lt;soap:Envelope xmlns:soap= "http://schemas.xmlsoap.org/soap/envelope/" &gt; ...
基于spring boot搭建axis1.4 服务端客户端
最新发布
zy1314567的博客
09-16 1939
3.3 创建webapp/WEB-INF/server-config.wsdd。3.5 修改spring boot启动类，添加注解。1. 创建spring boot项目。3.4 创建WebServlet。打开cmd，进入axis解压目录。2. 引入axis1.4依赖。执行结束后会出现以下内容。4.3 将文件拷贝到项目中。3. 创建service。3.2 创建接口实现类。4.2 创建client。4.4 创建客户端代码。3.1 创建服务接口。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值