springboot整合axis1.4搭建服务端

前言

最近公司要开发个接口，要用webservices接口实现，而且使用的是axis1.4框架，webservices和axis这两个东西我之前都没接触过，而且axis1.4这个框架06年就不再维护了，没办法，客户就是上帝。上网查了一圈，基本都是spring整合axis的，而公司用的是springboot,比较头疼，在此记录下搭建过程。

一、引入依赖

 <dependency>
 <groupId>org.apache.axis</groupId>
 <artifactId>axis</artifactId>
 <version>1.4</version>
 </dependency>

 <dependency>
 <groupId>axis</groupId>
 <artifactId>axis-jaxrpc</artifactId>
 <version>1.4</version>
 </dependency>

 <dependency>
 <groupId>commons-discovery</groupId>
 <artifactId>commons-discovery</artifactId>
 <version>0.2</version>
 </dependency>
 <dependency>
 <groupId>wsdl4j</groupId>
 <artifactId>wsdl4j</artifactId>
 <version>1.6.3</version>
 </dependency>

二、写个接口以及实现类

接口：

 public interface HelloService {
     public String sayHello(String info);

 }

实现类：

 public class HelloServiceImpl implements HelloService {
     public String sayHello(String info) {
         return "sayHello:"+info;
     }
 }

三、创建资源文件server-config.wsdd

 <?xml version="1.0" encoding="UTF-8"?>
 <deployment xmlns="http://xml.apache.org/axis/wsdd/"
     xmlns:java="http://xml.apache.org/axis/wsdd/providers/java">
     <handler type="java:org.apache.axis.handlers.http.URLMapper"
         name="URLMapper" />

     <!--要告诉别人的接口名-->
     <service name="HelloServiceImpl" provider="java:RPC">
         <!--这个是 实现类-->
         <parameter name="className" value="com.codefish.javalab.ws.server.HelloServiceImpl" />
         <!--这是是暴露的方法名   比如可以值暴露一个-->
         <parameter name="allowedMethods" value="sayHello" />
         <!--这是是暴露的方法名   也可以用* 表示暴露全部的public方法-->
         <!--<parameter name="allowedMethods" value="*" />-->
     </service>

     <transport name="http">
         <requestFlow>
             <handler type="URLMapper" />
         </requestFlow>
     </transport>

 </deployment>

四、添加servlet过滤规则

新建com.example.servlet.WebServlet,继承AxisServlet。

     package com.example.servlet;
     import org.apache.axis.transport.http.AxisServlet;
     @javax.servlet.annotation.WebServlet(
             urlPatterns =  "/services/*",
             loadOnStartup = 1,
             name = "AxisServlet"
     )
     public class WebServlet extends AxisServlet {

     }

五、重写Axis的配置工厂信息

因为我想要以jar包形式发布，所以需要重写EngineConfigurationFactory类，否则会访问不到。新建org.apache.axis.configuration.EngineConfigurationFactoryServlet，继承EngineConfigurationFactoryDefault。更改的是getServerEngineConfig(ServletConfig cfg)方法。（注意：该类需要放在org.apache.axis.configuration包下，我尝试放在其他路径下无效，如有大神知道，还望告知）

 /*
  * Copyright 2002-2004 The Apache Software Foundation.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */

 package org.apache.axis.configuration;

 import org.apache.axis.AxisProperties;
 import org.apache.axis.ConfigurationException;
 import org.apache.axis.EngineConfiguration;
 import org.apache.axis.EngineConfigurationFactory;
 import org.apache.axis.components.logger.LogFactory;
 import org.apache.axis.server.AxisServer;
 import org.apache.axis.utils.ClassUtils;
 import org.apache.axis.utils.Messages;
 import org.apache.commons.logging.Log;

 import javax.servlet.ServletConfig;
 import java.io.InputStream;

 /**
  * This is a default implementation of ServletEngineConfigurationFactory.
  * It is user-overrideable by a system property without affecting
  * the caller. If you decide to override it, use delegation if
  * you want to inherit the behaviour of this class as using
  * class extension will result in tight loops. That is, your
  * class should implement EngineConfigurationFactory and keep
  * an instance of this class in a member field and delegate
  * methods to that instance when the default behaviour is
  * required.
  *
  * @author Richard A. Sitze
  * @author Davanum Srinivas (dims@apache.org)
  */
 public class EngineConfigurationFactoryServlet
         extends EngineConfigurationFactoryDefault {
     protected static Log log =
             LogFactory.getLog(EngineConfigurationFactoryServlet.class.getName());

     private ServletConfig cfg;

     /**
      * Creates and returns a new EngineConfigurationFactory.
      * If a factory cannot be created, return 'null'.
      * <p>
      * The factory may return non-NULL only if:
      * - it knows what to do with the param (param instanceof ServletContext)
      * - it can find it's configuration information
      *
      * @see EngineConfigurationFactoryFinder
      */
     public static EngineConfigurationFactory newFactory(Object param) {
         /**
          * Default, let this one go through if we find a ServletContext.
          *
          * The REAL reason we are not trying to make any
          * decision here is because it's impossible
          * (without refactoring FileProvider) to determine
          * if a *.wsdd file is present or not until the configuration
          * is bound to an engine.
          *
          * FileProvider/EngineConfiguration pretend to be independent,
          * but they are tightly bound to an engine instance...
          */
         return (param instanceof ServletConfig)
                 ? new EngineConfigurationFactoryServlet((ServletConfig) param)
                 : null;
     }

     /**
      * Create the default engine configuration and detect whether the user
      * has overridden this with their own.
      */
     protected EngineConfigurationFactoryServlet(ServletConfig conf) {
         super();
         this.cfg = conf;
     }

     /**
      * Get a default server engine configuration.
      *
      * @return a server EngineConfiguration
      */
     public EngineConfiguration getServerEngineConfig() {
         return getServerEngineConfig(cfg);
     }

     /**
      * Get a default server engine configuration in a servlet environment.
      *
      * @param cfg a ServletContext
      * @return a server EngineConfiguration
      */
     private static EngineConfiguration getServerEngineConfig(ServletConfig cfg) {

         // Respect the system property setting for a different config file
         String configFile = cfg.getInitParameter(OPTION_SERVER_CONFIG_FILE);
         if (configFile == null)
             configFile =
                     AxisProperties.getProperty(OPTION_SERVER_CONFIG_FILE);
         if (configFile == null) {
             configFile = SERVER_CONFIG_FILE;
         }

         /**
          * Flow can be confusing.  Here is the logic:
          * 1) Make all attempts to open resource IF it exists
          *    - If it exists as a file, open as file (r/w)
          *    - If not a file, it may still be accessable as a stream (r)
          *    (env will handle security checks).
          * 2) If it doesn't exist, allow it to be opened/created
          *
          * Now, the way this is done below is:
          * a) If the file does NOT exist, attempt to open as a stream (r)
          * b) Open named file (opens existing file, creates if not avail).
          */

         /*
          * Use the WEB-INF directory
          * (so the config files can't get snooped by a browser)
          */
         String appWebInfPath = "/WEB-INF";
         //由于部署方式变更为jar部署，此处不可以使用改方式获取路径
 //        ServletContext ctx = cfg.getServletContext();
 //        String realWebInfPath = ctx.getRealPath(appWebInfPath);

         FileProvider config = null;
         String realWebInfPath = EngineConfigurationFactoryServlet.class.getResource(appWebInfPath).getPath();

         /**
          * If path/file doesn't exist, it may still be accessible
          * as a resource-stream (i.e. it may be packaged in a JAR
          * or WAR file).
          */
         InputStream iss = ClassUtils.getResourceAsStream(EngineConfigurationFactoryServlet.class, appWebInfPath+"/" + SERVER_CONFIG_FILE);
         if (iss != null) {
             // FileProvider assumes responsibility for 'is':
             // do NOT call is.close().
             config = new FileProvider(iss);
         }

         if (config == null) {
             log.error(Messages.getMessage("servletEngineWebInfError03", ""));
         }

         /**
          * Couldn't get data  OR  file does exist.
          * If we have a path, then attempt to either open
          * the existing file, or create an (empty) file.
          */
         if (config == null && realWebInfPath != null) {
             try {
                 config = new FileProvider(realWebInfPath, configFile);
             } catch (ConfigurationException e) {
                 log.error(Messages.getMessage("servletEngineWebInfError00"), e);
             }
         }

         /**
          * Fall back to config file packaged with AxisEngine
          */
         if (config == null) {
             log.warn(Messages.getMessage("servletEngineWebInfWarn00"));
             try {
                 InputStream is =
                         ClassUtils.getResourceAsStream(AxisServer.class,
                                 SERVER_CONFIG_FILE);
                 config = new FileProvider(is);

             } catch (Exception e) {
                 log.error(Messages.getMessage("servletEngineWebInfError02"), e);
             }
         }

         return config;
     }
 }

六、配置Application

添加注解 @ServletComponentScan

@SpringBootApplication
@ServletComponentScan //扫描自定义的WebFilter和WebListener,否则无法扫描到
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}

启动程序，访问http://localhost:8080/services，会将server-config.wsdd里面的接口发布出来，此时客户端可以调用接口。