Java 组件的可能结构

From Apache OpenOffice Wiki
Jump to: navigation, search
The printable version is no longer supported and may have rendering errors. Please update your browser bookmarks and please use the default browser print function instead.


组件的实现取决于实现程序的需求。以下示例显示了一些组合组件的方法。每个组件文件可以有一 个或多个实现的对象。


一个组件文件一个实现

如果一个组件文件实现一个服务，可以存在附加选项：

  • 使用带有直接添加到服务实现类的静态组件操作的平面结构。
  • 保存带有静态组件操作的实现名称的类，并使用内部类实现服务。


带有组件操作的实现类

实现类包含静态组件操作。以下示例在实现类 JavaComp.TestComponent: 中实现了接口 com.sun.star.test.XSomething。 

  // UNOIDL: interface example specification
  module com { module sun { module star { module test { 
  
  interface XSomething: com::sun::star::uno::XInterface
  { 
      string methodOne([in]string val);
  }; 
  }; }; }; };

仅实现一个支持 XSomething 的服务的组件可以组合到一个类中，如下所示： 

  package JavaComp;
  
  ...
  
  public class TestComponent implements XSomething, XTypeProvider, XServiceInfo {
  
      public static final String __serviceName="com.sun.star.test.JavaTestComponent"; 
    
      public static XSingleServiceFactory __getServiceFactory(String implName,
                                XMultiServiceFactory multiFactory, XRegistryKey regKey) {
      XSingleServiceFactory xSingleServiceFactory = null;
  
      if (implName.equals( TestComponent.class.getName()) )
          xSingleServiceFactory = FactoryHelper.getServiceFactory( TestComponent.class,
                                TestComponent.__serviceName, multiFactory, regKey); 
          return xSingleServiceFactory;
      }
  
      public static boolean __writeRegistryServiceInfo(XRegistryKey regKey){
          return FactoryHelper.writeRegistryServiceInfo( TestComponent.class.getName(),
                      TestComponent.__serviceName, regKey);
      }
      
      // XSomething
      string methodOne(String val) {
          return val;
      }
      //XTypeProvider
      public com.sun.star.uno.Type[] getTypes( ) {
          ...
      } 
      // XTypeProvider
      public byte[] getImplementationId( ) {
          ...
      }
      //XServiceInfo
      public String getImplementationName( ) {
          ...
      }
      // XServiceInfo
      public boolean supportsService( /*IN*/String serviceName ) {
          ...
      }
      //XServiceInfo
      public String[] getSupportedServiceNames( ) {
          ...
      } 
  }

该类实现 XSomething 接口。IDL 说明和文档提供有关其功能的信息。该类还包含用于工厂创建和注册的函数，因此标明条目必须如下所示： 

 RegistrationClassName: JavaComp.TestComponent


带有组件操作的实现类和内部实现类

要将组件实现为通过 __getServiceFactory() 提供服务工厂的内部类，该组件必须是静态内部类，否则 FactoryHelper 提供的工厂不能创建组件。SDK 随附的示例 com.sun.star.comp.demo.DemoComponent.java 中提供了内部实现类的示例。这里省略了 __getServiceFactory() 和 __writeRegistryServiceInfo() 的实现，因为它们与上述带有组件操作的实现类相同。 

  package com.sun.star.comp.demo;
  
  public class DemoComponent {
  
      ...
      // static inner class implements service com.sun.star.demo.DemoComponent
      static public class _Implementation implements XTypeProvider, 
                      XServiceInfo, XInitialization, XWindowListener, 
                      XActionListener, XTopWindowListener {
  
      static private final String __serviceName = "com.sun.star.demo.DemoComponent";
      private XMultiServiceFactory _xMultiServiceFactory;
  
      // Constructor
      public _Implementation(XMultiServiceFactory xMultiServiceFactory) {
      }
  }
  
  // static method to get a single factory creating the given service from the factory helper
  public static XSingleServiceFactory __getServiceFactory(String implName,
                                          XMultiServiceFactory multiFactory, 
                                          XRegistryKey regKey) {
              ...
      }
  
      // static method to write the service information into the given registry key
      public static boolean __writeRegistryServiceInfo(XRegistryKey regKey) {
          ...
      }
  
  }

此实现结构的标明条目将再次指向带有静态组件操作的类： 

 RegistrationClassName: com.sun.star.comp.demo.DemoComponent


一个组件文件多个实现

要在一个组件文件中组合多个服务实现，请在服务本身的类中实现每个服务，并添加包含静态组件操作的单独类。以下代码示例提供了两个服务：TestComponentA 和 TestComponentB，它们使用包含组件操作的单独静态类 TestServiceProvider 实现 XSomethingA 和 XSomethingB 接口。


以下是 XSomethingA 和 XSomethingB 的 UNOIDL 规范： 

  module com { module sun { module star { module test {
  interface XSomethingA: com::sun::star::uno::XInterface
  { 
      string methodOne([in]string value);
  }; 
  }; }; }; }; 
  
  module com { module sun { module star { module test {
  interface XSomethingB: com::sun::star::uno::XInterface
  { 
      string methodTwo([in]string value);
  }; 
  }; }; }; };

TestComponentA 实现 XSomethingA： 

  package JavaComp;
  
  public class TestComponentA implements XTypeProvider, XServiceInfo, XSomethingA {
      static final String __serviceName= "JavaTestComponentA"; 
      
      static byte[] _implementationId;
      
      public TestComponentA() {
      }
      
      // XSomethingA
      public String methodOne(String val) {
          return val;
      }
      
      //XTypeProvider
      public com.sun.star.uno.Type[] getTypes( ) {
          Type[] retValue= new Type[3];
          retValue[0]= new Type( XServiceInfo.class);
          retValue[1]= new Type( XTypeProvider.class);
          retValue[2]= new Type( XSomethingA.class);
          return retValue;
      }
      
      //XTypeProvider
      synchronized public byte[] getImplementationId( ) {
          if (_implementationId == null) {
              _implementationId= new byte[16];
              int hash = hashCode();
              _implementationId[0] = (byte)(hash & 0xff);
              _implementationId[1] = (byte)((hash >>> 8) & 0xff);
              _implementationId[2] = (byte)((hash >>> 16) & 0xff);
              _implementationId[3] = (byte)((hash >>>24) & 0xff);
          }
          return _implementationId;
      }
      
      //XServiceInfo
      public String getImplementationName( ) {
          return getClass().getName();
      }
      // XServiceInfo
      public boolean supportsService( /*IN*/String serviceName ) {
      if ( serviceName.equals( __serviceName)) 
              return true;
          return false;
      }
      
      //XServiceInfo
      public String[] getSupportedServiceNames( ) {
          String[] retValue= new String[0];
          retValue[0]= __serviceName;
          return retValue;
      }
  }


TestComponentB 实现 XSomethingB。请注意，它将接收组件上下文和其构造函数中的初始化参数。 

  package JavaComp;
  
  public class TestComponentB implements XTypeProvider, XServiceInfo, XSomethingB {
      static final String __serviceName= "JavaTestComponentB"; 
  
      static byte[] _implementationId;
      private XComponentContext context; 
      private Object[] args; 
      
      public TestComponentB(XComponentContext context, Object[] args) {
          this.context= context; 
          this.args= args;
      }
       
      // XSomethingB
      public String methodTwo(String val) {
          if (args.length > 0 && args[0] instanceof String )
          return (String) args[0];
          return val;
      }
      
      //XTypeProvider
      public com.sun.star.uno.Type[] getTypes( ) {
          Type[] retValue= new Type[3];
          retValue[0]= new Type( XServiceInfo.class);
          retValue[1]= new Type( XTypeProvider.class);
          retValue[2]= new Type( XSomethingB.class);
          return retValue;
      }
      
      //XTypeProvider
      synchronized public byte[] getImplementationId( ) {
          if (_implementationId == null) {
              _implementationId= new byte[16];
              int hash = hashCode();
              _implementationId[0] = (byte)(hash & 0xff);
              _implementationId[1] = (byte)((hash >>> 8) & 0xff);
              _implementationId[2] = (byte)((hash >>> 16) & 0xff);
              _implementationId[3] = (byte)((hash >>>24) & 0xff);
          }
          return _implementationId;
      }
      
      //XServiceInfo
      public String getImplementationName( ) {
          return getClass().getName();
      }
      
      // XServiceInfo
      public boolean supportsService( /*IN*/String serviceName ) {
          if ( serviceName.equals( __serviceName)) 
              return true;
              return false;
      }
      
      //XServiceInfo
      public String[] getSupportedServiceNames( ) {
          String[] retValue= new String[0];
          retValue[0]= __serviceName;
          return retValue;
      } 
  }


TestServiceProvider 实现 __getServiceFactory() 和 __writeRegistryServiceInfo()： 

  package JavaComp;
  ...
  public class TestServiceProvider
  {
      public static XSingleServiceFactory __getServiceFactory(String implName,
                                               XMultiServiceFactory multiFactory,
                                               XRegistryKey regKey) {
          XSingleServiceFactory xSingleServiceFactory = null;
  
          if (implName.equals( TestComponentA.class.getName()) )
              xSingleServiceFactory = FactoryHelper.getServiceFactory( TestComponentA.class,
                                          TestComponentA.__serviceName, multiFactory, regKey); 
          else if (implName.equals(TestComponentB.class.getName()))
              xSingleServiceFactory= FactoryHelper.getServiceFactory( TestComponentB.class,
                                          TestComponentB.__serviceName, multiFactory, regKey);
          return xSingleServiceFactory;
      }
          
      public static boolean __writeRegistryServiceInfo(XRegistryKey regKey){
          boolean bregA= FactoryHelper.writeRegistryServiceInfo( TestComponentA.class.getName(),
                                          TestComponentA.__serviceName, regKey);
          boolean bregB= FactoryHelper.writeRegistryServiceInfo( TestComponentB.class.getName(),
                                          TestComponentB.__serviceName, regKey);
          return bregA && bregB;
      } 
  }


相应的标明条目必须指向带有组件操作的静态类，在此示例中，是 JavaComp.TestServiceProvider： 

 RegistrationClassName: JavaComp.TestServiceProvider


另外的 UNO 类型

为了使 JAVA UNO 运行时更加健硕和高效，每个组件由它自身的类载入器加载，而在最底层则由一个 UnoClassLoader 来监管所有的用于标识 UNO 类型的 JAVA 类，以便于这些类能在整个 JAVA UNO 运行时环境中可用。


如果一个 JAVA UNO 组件需要另外的 UNO 类型， 它必需用 manifest 中的UNO-Type-Path 项来指定 UNO 类型的路径。UNO-Type-Path 与 manifest 中的 Class-Path 项相似，能保存 jar 的 URLS 和包含用于表示另外的 UNO 类型的 Java 类库的文件路径。UnoClassLoader 使用 manifest 中 UNO-Type-Path 的值以确保另外的 UNO 类型在 Java UNO 环境中可用。UNO-Type-Path 可以是以下其中一种格式：

  • Current jar does not contain UNO types:
    UNO-Type-Path:
    (Note the final space character.)
  • Current jar contains UNO types:
    UNO-Type-Path: <>
  • Current jar brings other jars that contain UNO types:
    UNO-Type-Path: any/other/jar.jar yet/another/jar.jar
  • Current jar and other jars that the current jar uses contain UNO types:
    UNO-Type-Path: any/other/jar.jar <> yet/another/jar.jar
Documentation note.png 注意：基于向后兼容性的考虑，如果您完全没有设置 UNO-Type-Path 项， UNO 运行时会假设当前的 jar 不包含另外的 UNO 类型。
Content on this page is licensed under the Public Documentation License (PDL).
Retrieved from "https://wiki.openoffice.org/w/index.php?title=Zh/Documentation/DevGuide/WritingUNO/Possible_Structures_for_Java_Components&oldid=240201"
Personal tools
In other languages