Приложение A Использование неприсоединённого кода от Java

#include <windows.h>

#include <stdio.h>

public class ShowMsgBox {
  public static void main(String[] args) {
    ShowMsgBox app = new ShowMsgBox();
    app.showMessage("Сгенерировано с помощью JNI");
  }

  private native void showMessage(String msg);

  static {
    System.loadLibrary("MsgImpl");
  }
}
```После объявления встроенного метода следует статический блок кода, который вызывает `System.loadLibrary()`. Это можно делать в любое время, но так будет более подходящим. `System.loadLibrary()` загружает библиотеку DLL в память и устанавливает связь с ней. Библиотека DLL должна находиться в системной директории или в том же каталоге, где находятся Java классы. В зависимости от конкретной платформы JVM автоматически добавляет соответствующее расширение файла.### Примечание к директиве препроцессора `#ifdef __cplusplus`

Из директивы препроцессора `#ifdef __cplusplus` можно сделать вывод, что этот файл может компилироваться как C-компилятором, так и C++-компилятором. В начале файла используется команда `#include`, которая включает заголовочный файл `jni.h`, определяющий типы данных, используемые в остальной части файла. Макросы `JNIEXPORT` и `JNICALL` расшифровываются таким образом, чтобы работать с платформозависимыми вызовами, а также используются JNI-определённые данные типа `JNIEnv`, `jobject` и `jstring`.

Также стоит отметить, что конструкция `extern "C"` позволяет использовать этот заголовочный файл в C++-коде, обеспечивая корректность внешних объявлений при взаимодействии с C-библиотеками.#### 2. Управление именами и сигнатуры функций

JNI стандартизирует названия методов, реализованных на языках программирования; это важно, поскольку является частью механизма, связывающего вызовы Java с внутренними методами. В общем, все внутренние методы должны начинаться со слова «Java», за которым следует имя Java-метода; разделитель используется в виде символа подчеркивания. Если Java-методы имеют несколько реализаций (перегрузка), то к имени добавляется сигнатура функции. В комментариях перед прототипом можно найти описание внутренней сигнатуры. Для получения более подробной информации о правилах названий и сигнатур внутренних методов обратитесь к соответствующей документации JNI.

#### 3. Реализация собственного DLL

На данном этапе требуется написать C- или C++-файл, содержащий заголовочные файлы, созданные с помощью `javah`; затем реализовать внутренние методы; и скомпилировать его, чтобы получить динамически связываемую библиотеку (DLL). Эта часть работы зависит от конкретной платформы, поэтому предполагается, что читатель уже знает, как создать DLL. Ниже приведён пример кода, реализующий внутренний метод через вызов Win32-API:

```c
#include <windows.h>
#include "ShowMsgBox.h"

BOOL APIENTRY DllMain(HANDLE hModule,
                       DWORD dwReason, void** lpReserved) {
    return TRUE;
}
``````java
JNIEXPORT void JNICALL
Java_ShowMsgBox_ShowMessage(JNIEnv * jEnv,
  jobject this, jstring jMsg) {
  const char * msg;
  msg = (*jEnv)->GetStringUTFChars(jEnv, jMsg, 0);
  MessageBox(HWND_DESKTOP, msg,
    "Thinking in Java: JNI",
    MB_OK | MB_ICONEXCLAMATION);
  (*jEnv)->ReleaseStringUTFChars(jEnv, jMsg, msg);
}

### А.1.2 Доступ к JNI функциям: параметр `JNIEnv`

С помощью JNI функций программист может взаимодействовать с JVM изнутри внутреннего метода. Как вы видели в примерах выше, каждый JNI внутренний метод принимает специальный параметр — первый параметр: параметр `JNIEnv`, который является указателем на специальную структуру данных JNI типа `JNIEnv_`. Элемент структуры JNI представляет собой указатель на массив, созданный JVM; каждый элемент этого массива является указателем на JNI функцию. Вызов JNI функций изнутри внутреннего метода осуществляется путём отмены ссылок на эти указатели (что на самом деле очень просто). Каждый JVM реализует JNI функции своим способом, но их адреса точно находятся в заранёженных смещениях.

Параметр `JNIEnv` позволяет программисту получать доступ к ряду функций. Эти функции можно разделить на следующие категории:

+ Получение информации о версии
+ Операции с классами и объектами
+ Управление глобальными и локальными ссылками на Java объекты
+ Доступ к экземплярным полям и статическим полям
+ Вызов экземплярных методов и статических методов
+ Выполнение операций со строками и массивами
+ Создание и управление Java исключениямиКоличество JNI функций довольно велико, поэтому здесь мы не будем углубляться в детали. Вместо этого мы раскроем некоторые основные принципы использования этих функций. Для получения более подробной информации обратитесь к документации JNI вашего компилятора.

Если внимательно рассмотреть заголовочный файл `jni.h`, то можно заметить, что при компиляции C++ компилятором структура `JNIEnv_` определяется как класс внутри условия препроцессора `#ifdef _cplusplus`. Этот класс содержит множество встроенных функций. С помощью простого и знакомого синтаксиса эти функции позволяют легко обращаться к JNI функциям. Например, в предыдущем примере содержится следующий код:

```cpp
(*jEnv)->ReleaseStringUTFChars(jEnv, jMsg, msg);

jEnv->ReleaseStringUTFChars(jMsg, msg);

class MyJavaClass {
  public void divByTwo() { aValue /= 2; }
  public int aValue;
}

public class UseObjects {
  public static void main(String[] args) {
    UseObjects app = new UseObjects();
    MyJavaClass anObj = new MyJavaClass();
    anObj.aValue = 2;
    app.changeObject(anObj);
    System.out.println("Java: " + anObj.aValue);
  }

  private native void changeObject(MyJavaClass obj);
}
```  static {
    System.loadLibrary("UseObjImpl");
  }
}

public class ShowMsgBox {
    public static void main(String[] args) throws UnsatisfiedLinkError {
        MessageBox(0,
            "Создано с помощью MessageBox() Win32 функции",
            "Thinking in Java", 0);
    }

    /** @dll.import("USER32") */
    private static native int MessageBox(int hwndOwner, String text,
                                          String title, int fuStyle);
}
``````Шокирующим является то, что здесь представлено все необходимое кодовое содержимое для вызова функций Win32 DLL с помощью J/Direct. Ключевой особенностью являются `@dll.import` указательные команды перед объявлением `MessageBox()`, расположенные в нижней части демонстрационного кода. На первый взгляд они выглядят как комментарии, но это не так. Эти команды предназначены для того, чтобы сообщить компилятору, что функции ниже этой строки реализованы в библиотеке USER32 DLL и должны вызываться соответственно. Все, что нам нужно сделать, — это предоставить прототип функции, который соответствует функциям внутри DLL, и затем вызвать эти функции. Однако нет необходимости вручную вводить каждый Win32 API функционал в версии Java; Microsoft Java пакет сделает это за нас (мы подробнее рассмотрим это позже). Для того чтобы пример работал правильно, функции должны быть "по имени" экспортированы из DLL. Однако можно также использовать `@dll.import` указательные команды для "последовательной" связи. Например, мы можем указать положение входа функции в DLL. Мы более подробно рассмотрим возможности `@dll.import` указательных команд.
```Одним из важных вопросов при использовании неприсоединённого кода является автоматическое конфигурирование аргументов функций. Как видно, объявление `MessageBox()` в Java использует два строковых параметра, тогда как оригинальная C-версия использует два указателя типа char. Компилятор поможет нам автоматически преобразовать стандартные типы данных, следуя правилам, которые будут описаны в последней части главы.

Кроме того, возможно, вы заметили исключение `UnsatisfiedLinkError` в объявлении `main()`. Это исключение активируется во время выполнения, если связывающая программа не может распознать символы из неприсоединённой функции. Причины этого могут быть различными: отсутствие .dll файла, недействительность DLL или отсутствие поддержки J/Direct вашей используемой виртуальной машиной Java. Чтобы найти DLL, она должна находиться либо в каталогах Windows или Windows\System, либо в одном из каталогов, перечисленных в переменной окружения PATH, либо в том же каталоге, где находится .class файл. J/Direct поддерживается Microsoft Java компиляторами версий 1.02.4213 и выше, а также Microsoft JVM версий 4.79.2164 и выше. Чтобы узнать номер версии вашего компилятора, запустите JVC из командной строки без использования параметров. Чтобы узнать номер версии JVM, найдите значок msjava.dll и просмотрите его свойства через контекстное меню правого клика.### А.3.1 `@dll.import` Указательные Команды

Как единственный способ использования J/Direct, командный указатель `@dll.import` довольно гибок. Он предоставляет множество модификаторов, с помощью которых можно настраивать способ установления связи с неприспособленным для Java кодом. Его также можно применять как к отдельным методам внутри класса, так и ко всему классу в целом. Это значит, что все методы, объявленные в этом классе, реализуются в одной и той же DLL. Давайте более подробно рассмотреть эти возможности.

##### 1. Обработка псевдонимов и последовательная связывание

Чтобы команда `@dll.import` работала так, как показано выше, функции внутри DLL должны быть экспортированы по имени. Однако иногда мы хотим использовать имя, отличное от оригинального имени в DLL (обработка псевдонимов), а не экспортировать функцию по порядковому номеру (например, последовательно). В следующем примере объявлен метод `FinestraDiMessaggio()` (итальянское название для `MessageBox`). Как видно, синтаксис очень прост.

```java
public class Aliasing {
  public static void main(String[] args) 
  throws UnsatisfiedLinkError {
    FinestraDiMessaggio(0, 
      "Создано командой MessageBox() Win32", 
      "Размышления над Java", 0);
  }

  /** @dll.import("USER32", 
  entrypoint="MessageBox") */
  private static native int 
  FinestraDiMessaggio(int hwndOwner, String text, 
    String title, int fuStyle);
}
```В этом примере показано, как можно связывать функцию, которая не экспортирована по имени в DLL, но фактически экспортирована по её положению в DLL. Предположим, что есть DLL с именем `MYMATH`, содержащая функцию на позиции 3, которая принимает два целых числа в качестве аргументов и возвращает их сумму.```java
public class ByOrdinal {
  public static void main(String[] args)
  throws UnsatisfiedLinkError {
    int j = 3, k = 9;
    System.out.println("Результат работы функции DLL: "
      + Add(j, k));
  }

  /** @dll.import("MYMATH", entrypoint = "#3") */
  private static native int Add(int op1, int op2);
}

/** @dll.import("USER32") */
class MyUser32Access {
  public static native int
  MessageBox(int hwndOwner, String text,
    String title, int fuStyle);

  public native static boolean
  MessageBeep(int uType);
}

public class WholeClass {
  public static void main(String[] args)
  throws UnsatisfiedLinkError {
    MyUser32Access.MessageBeep(4);
    MyUser32Access.MessageBox(0,
      "Создано командой MessageBox() Win32",
      "Размышления над Java", 0);
  }
}

import com.ms.win32.*;

public class UseWin32Package {
  public static void main(String[] args) {
    try {
      User32.MessageBeep(winm.MB_ICONEXCLAMATION);
      User32.MessageBox(0, "Создано с помощью функции MessageBox() Win32", "Thinking in Java", winm.MB_OKCANCEL | winm.MB_ICONEXCLAMATION);
    } catch (UnsatisfiedLinkError e) {
      System.out.println("Не удалось связать Win32 API");
      System.out.println(e);
    }
  }
}
```Пакет Java импортирован первой строчкой. Теперь вы можете вызывать функции `MessageBeep()` и `MessageBox()` без необходимости делать дополнительные объявления. В функции `MessageBeep()` видны константы Win32, которые также объявлены при импорте пакета. Эти константы определены во многих Java-интерфейсах, названных `winx` (`x` представляет первую букву константы).На момент написания этой книги разработка пакета `com.ms.win32` ещё не завершена, но он уже вполне работоспособен.

### А.3.3 Объединение "Сериализация" (marshalling) — это процесс преобразования аргумента функции из его исходной двоичной формы в независимую от языка программирования форму, а затем конвертации этой универсальной формы в двоичный формат, подходящий для вызова функции. В предыдущем примере мы вызвали функцию `MessageBox()`, передав ей две строки. Функция `MessageBox()` является C-функцией, и бинарная структура Java-строк отличается от структуры C-строк. Однако параметры всё равно были правильно переданы благодаря тому, что J/Direct уже выполнил необходимое преобразование Java-строк в C-строки до вызова C-кода. Это применимо ко всем стандартным типам данных Java. Ниже приведена таблица, которая сводит кратко простые данные с их соответствующими типами:

```markdown
| Java Type | Corresponding C Type |
|-----------|----------------------|
| boolean   | jboolean             |
| byte      | jbyte                |
| short     | jshort               |
| int       | jint                 |
| long      | jlong                |
| float     | jfloat               |
| double    | jdouble              |
| char      | jchar                |

import com.ms.dll.*;
import com.ms.win32.*;

class EnumWindowsProc extends Callback {
  public boolean callback(int hwnd, int lParam) {
    StringBuffer text = new StringBuffer(50);
    User32.GetWindowText(hwnd, text, text.capacity() + 1);
    if (text.length() != 0)
      System.out.println(text);
    return true;  // чтобы продолжить перечисление.
  }
}

public class ShowCallback {
  public static void main(String[] args)
      throws InterruptedException {
    boolean ok = User32.EnumWindows(new EnumWindowsProc(), 0);
    if (!ok)
      System.err.println("EnumWindows failed.");
    Thread.currentThread().sleep(3000);
  }
}

/* НЕ РЕДАКТИРОВАТЬ - автоматически создано msjavah */
#include <native.h>
#pragma warning(disable:4510)
#pragma warning(disable:4512)
#pragma warning(disable:4610)

struct Classjava_lang_String;
#define Hjava_lang_String Classjava_lang_String

/* Заголовок для класса ShowMsgBox */

#ifndef _Included_ShowMsgBox
#define _Included_ShowMsgBox

#define HShowMsgBox ClassShowMsgBox
typedef struct ClassShowMsgBox {
#include <pshpack4.h>
  long MSReserved;
#include <poppack.h>
} ClassShowMsgBox;

#ifdef __cplusplus
extern "C" {
#endif
__declspec(dllexport) void __cdecl
ShowMsgBox_ShowMessage (struct HShowMsgBox *,
  struct Hjava_lang_String *);
#ifdef __cplusplus
}
#endif

#endif  /* _Included_ShowMsgBox */

#pragma warning(default:4510)
#pragma warning(default:4512)
#pragma warning(default:4610)
```Помимо ухудшения удобочитаемости, этот код скрывает некоторые технические проблемы, которые будут рассмотрены ниже.

В RNI программисты нативных методов знают двоичную структуру объектов. Это позволяет нам напрямую обращаться к нужной информации; мы не должны получать идентификаторы полей или методов, как это происходит в JNI. Однако, поскольку не все виртуальные машины используют одну и ту же двоичную структуру для своих объектов, указанный выше нативный метод работает только в Microsoft JVM.В RNI через параметр JNIEnv доступна большая часть функций для взаимодействия с JVM. В RNI функции управления работой JVM становятся вызываемыми напрямую. Некоторые из них (например, управление исключениями) похожи на свои "братья" из JNI. Но большинство функций RNI имеют другие имена и назначение по сравнению с JNI. Наиболее значительной разницей между JNI и RNI является модель "мусорной сборки". В JNI мусорная сборка во время выполнения встроенных методов следует тем же правилам, что и при выполнении кода на Java. В то время как в RNI управление мусорной сборкой во время работы встроенных методов возложено на программиста. По умолчанию мусорный сборщик находится в режиме выключенного состояния до тех пор, пока программа не войдет в область выполнения встроенных методов; таким образом, программист может предположить, что объекты, используемые в этот период времени, не будут являться целью мусорной сборки. Однако если встроенный метод планируется длительное время выполнять, программист должен рассмотреть возможность активации мусорного сборщика — путём вызова функции `GCEnable()` (где GC сокращение от "Garbage Collector", то есть "мусорный сборщик").Существует также механизм, аналогичный глобальным ссылкам — программист может использовать его для обеспечения того, чтобы определённые объекты не были удалены сборщиком мусора во время его работы. Концепция здесь такая же, но названия отличаются — в RNI это называется `GCFrames`.

### А.4.1 Обзор RNI

Факт тесной интеграции RNI с Microsoft JVM одновременно является и преимуществом, и недостатком. RNI значительно сложнее JNI, однако он предоставляет высокий уровень контроля над внутренней работой JVM, включая управление сборкой мусора. Кроме того, он явно оптимизирован для скорости и использует некоторые компромиссы и техники, знакомые C-программистам. Однако этот подход не применим к другим реализациям JVM.## А. 5 Интеграция Java/COM (ранее известное как OLE) представляет собой «компонентную объектную модель» (Component Object Model) компании Microsoft. Это основа всех технологий ActiveX (включая ActiveX-контролы, Automation и ActiveX-документы). Однако COM включает в себя гораздо больше. Это спецификация, согласно которой созданные по ней компонентные объекты могут взаимодействовать друг с другом через специальные возможности операционной системы. В реальных приложениях все новые программы для Win32-систем связаны с COM — операционная система раскрывает свои возможности через COM-объекты. Компоненты, созданные другими производителями, также могут базироваться на COM, позволяя нам создавать и регистрировать свои собственные COM-компоненты. Независимо от формы, если вы хотите писать код для Win32, вам придется иметь дело с COM. В этом разделе мы просто повторим основные концепции программирования COM, предполагая, что читатель уже знаком с понятиями COM-сервера (любой COM-объект, который может предоставлять услуги COM-клиентам) и COM-клиента (любого COM-объекта, который может запрашивать услуги у COM-сервера). Мы постараемся сделать объяснение максимально простым. На самом деле, эти инструменты гораздо мощнее, и мы можем использовать их более продвинутыми способами. Но это требует более глубокого понимания COM, выходящего за рамки данного приложения.Если вас интересуют мощные, но платформозависимые возможности, рекомендуется изучить документацию по COM и материалы Microsoft, особенно разделы, связанные с интеграцией Java/COM. Для получения дополнительной информации я советую книгу Дэйла Рогерсона "Inside COM", выпущенную издательством Microsoft Press в 1997 году. Использование COM (Component Object Model) является ключевой частью всех новых приложений Win32, поэтому способность использовать (или раскрывать) службы COM с помощью Java-кода становится особенно важной. Интеграция Java/COM бесспорно является одним из самых интересных аспектов компилятора Microsoft Java и виртуальной машины. Так как модели Java и COM очень похожи, эта интеграция кажется интуитивной и легко реализуется технически — для доступа к COM практически не требуется писать специальный код. Большинство технических деталей контролируется компилятором и/или виртуальной машиной. В результате Java-программист может обращаться к объектам COM так же, как к обычным Java-объектам. Также клиенты COM могут использовать серверы COM, реализованные на Java, точно так же, как они используют другие серверы COM.Здесь стоит отметить, что хотя я использую общие термины "COM", можно полностью реализовать ActiveX Automation Server на Java, а также использовать ActiveX Control в Java-приложении.

Наиболее примечательное сходство между Java и COM заключается в том, как COM-интерфейсы соотносятся с ключевым словом `interface` в Java. Это почти идеальное соответствие, поскольку:

+   Объекты COM раскрывают только интерфейсы;
+   Сам по себе COM-интерфейс не имеет реализации; его реализация осуществляется объектом COM, который раскрывает этот интерфейс;
+   COM-интерфейс представляет собой описание семантически связанных набора функций; он не раскрывает никаких данных;
+   COM-класс объединяет несколько COM-интерфейсов. Java-класс может реализовать любое количество Java-интерфейсов;
+   COM имеет модель ссылочных объектов; программист никогда не "владеет" объектом, а лишь получает ссылку на один или более интерфейсов этого объекта. У Java тоже есть модель ссылочных объектов — ссылка на объект может быть преобразована в ссылку на один из его интерфейсов;
+   "Жизненный цикл" объекта COM в памяти зависит от количества клиентов, использующих этот объект; если это число становится нулевым, объект сам удаляет себя из памяти. В Java жизненный цикл объекта также определяется количеством клиентов, использующих его; если больше нет ссылок на объект, он ждет сборки мусора.Эта близкая корреляция между Java и COM позволяет Java-программистам удобно использовать возможности COM, а также делает Java эффективным языком для написания кода COM. Хотя COM является языково-нейтральным, фактический язык разработки COM обычно C++ и Visual Basic. По сравнению с Java, C++ предоставляет более мощные средства для разработки COM и может генерировать более эффективный код, но он сложнее в использовании. Visual Basic намного проще Java, но находится слишком далеко от базовой операционной системы, и его модель объектов не обеспечивает такой же степени совместимости. Хорошее соответствие (соответствие) между ними. Java является хорошей компромиссной схемой для обоих.

Далее мы рассмотрим некоторые ключевые вопросы, связанные с разработкой COM. Эти вопросы следует выяснить первыми при создании клиентских и серверных приложений на Java/COM.

### 5.1 Основы COMCOM — это бинарный стандарт, предназначенный для обеспечения взаимодействия объектов. Например, COM считает, что двоичное представление одного объекта должно позволять вызывать службы другого COM-объекта. Поскольку это описание двоичного представления, любой язык, который может генерировать такое представление, может использоваться для создания COM-объектов. Обычно программисты не должны беспокоиться о таких деталях уровня, поскольку компиляторы могут автоматически создавать правильное представление. Например, если ваша программа написана на C++, большинство компиляторов будут создавать виртуальную таблицу функций, соответствующую стандарту COM. Для языков, которые не генерируют исполняемый код, таких как VB и Java, соединение с COM происходит автоматически во время выполнения.Библиотека COM также предоставляет несколько базовых функций, таких как функции для создания объектов или поиска уже зарегистрированных COM-классов в системе.

Основные цели модели объектов COM включают:

+   Возможность вызова служб одним объектом от другого объекта

+   Возможность бесшовного внедрения новых типов объектов (или обновленных объектов)Первое из этих целей решается задачами объектно-ориентированного программирования: у нас есть клиентский объект, который может обращаться к серверному объекту. В этом контексте термины "клиент" и "сервер" используются в обычном смысле, а не относятся к конкретным аппаратным конфигурациям. Для любого объектно-ориентированного языка первая цель легко достижима — просто ваш код представляет собой полный блок кода, который реализует как код клиента, так и код сервера. При изменении формы взаимодействия между клиентским и серверным объектами достаточно просто перекомпилировать и перезапустить приложение; при следующем запуске оно будет использовать самые новые версии компонентов. Однако если приложение состоит из компонентных объектов, которые находятся вне нашего контроля, ситуация может значительно отличаться — мы не контролируем их исходный код, а их обновление может происходить независимо от нашего приложения. Например, когда мы используем ActiveX-компоненты, разработанные другими производителями, в своём приложении, это становится актуальным. Компоненты устанавливаются в нашу систему, и наше приложение может (в процессе выполнения) найти серверный код, активировать объект, установить с ним связь и использовать его.Впоследствии мы можем установить новые версии этих компонентов, и наше приложение должно продолжать работать; даже в худшем случае оно должно вежливо сообщить об ошибке, например "Компонент не найден" и так далее; обычно оно не должно внезапно зависнуть или выйти из строя. В этих случаях наши компоненты реализуются в независимых исполняемых файлах кода: DLL или EXE. Если серверные объекты реализованы в независимых исполняемых файлах кода, требуется стандартный метод, предоставляемый операционной системой, чтобы активировать эти объекты. Конечно же, мы не хотим использовать физические имена и расположение DLL или EXE в нашем коде, так как эти параметры могут часто меняться. В этом случае нам нужны идентификаторы, поддерживаемые самой операционной системой. Кроме того, наша программа должна иметь описание услуг, представленных сервером. Два следующих раздела будут рассматривать эти две проблемы.##### 1. GUID и реестр

COM использует структурированные целочисленные значения (длиной 128 бит) для уникальной идентификации зарегистрированных в системе COM объектов. Эти числа имеют официальное название — GUID (Globally Unique Identifier, глобально уникальный идентификатор), который может быть сгенерирован специальными инструментами. Кроме того, эти числа гарантируют уникальность "в любом пространстве и времени", то есть они никогда не повторятся. Пространственно это обеспечивается за счет чтения номера сетевой карты генератором чисел; временно — благодаря использованию системы дат и времени. GUID можно использовать для идентификации COM-классов (тогда он называется CLSID) или COM-интерфейсов (IID). Несмотря на различия в названии, базовая концепция и двоичная структура одинаковы. GUID также могут применяться в других контекстах, что здесь не будет подробно рассматриваться.GUID и связанные с ними данные хранятся в Windows-реестре, или, другими словами, в "регистрационной базе данных" (registration database). Это иерархическая база данных, которая встроена в операционную систему и содержит большое количество информации, связанной с конфигурацией программного и аппаратного обеспечения системы. Для COM реестр отслеживает установленные в системе компоненты, такие как их CLSID, имя и местоположение исполняющих их файлов, а также множество других деталей. Одним из важнейших таких деталей является ProgID компонента; ProgID аналогичен по концепции GUID, поскольку оба служат для идентификации COM-компонента. Отличие заключается в том, что GUID представляет собой двоичное значение, сгенерированное алгоритмически, тогда как ProgID — это строковое значение, определяемое программистом. ProgID присваивается вместе с одним CLSID.Мы говорим о регистрации COM-компонента в системе, если его CLSID и исполняющий его файл уже существуют в реестре (ProgID обычно также присутствует). В последующих примерах основной задачей будет регистрация и использование COM-компонентов. Одним из важных свойств реестра является его использование в качестве деконнектированного слоя между клиентами и серверными объектами. Используя информацию, хранящуюся в реестре, клиент активирует сервер; одной из этих сведений является физическое расположение модуля выполнения сервера. В случае изменения этого положения информация в реестре будет обновлена соответственно. Однако этот процесс обновления остаётся "невидимым" для клиента. Для последнего достаточно использовать ProgID или CLSID напрямую. Другими словами, реестр делает возможной прозрачность местоположения кода сервера. С появлением DCOM (Distributed COM) сервер, работающий локально на машине, может быть перемещён на удалённую машину в сети, при этом весь процесс остаётся незамеченным для клиента (в большинстве случаев).Примечание: Исходный текст был на китайском, но для правильного понимания задачи было указано, что язык исходного текста необходимо определить. Учитывая контекст и содержание текста, можно сделать вывод, что он был написан на английском и затем переведён на китайский. Поэтому перевод выполнен на русский язык, как было указано в условии задачи.

##### 2. Типовые библиотекиИз-за возможности динамической связи в COM, а также потому что клиентский и серверный код могут развиваться независимо друг от друга, клиент всегда должен динамически обнаруживать услуги, предоставляемые сервером. Эти услуги описываются в виде двоичной формы, независимой от языка программирования, с использованием "типовой библиотеки" (Type Library) (как это делается для интерфейсов и сигнатур методов). Она может быть как самостоятельным файлом (обычно с расширением .TLB), так и Win32-ресурсом, связанным с исполняемым файлом. В процессе выполнения клиент использует информацию из типовой библиотеки для вызова функций на сервере.

Можно написать исходный файл на языке определения интерфейса Microsoft (Microsoft Interface Definition Language, MIDL), скомпилировать его с помощью компилятора MIDL и получить файл .TLB. Язык MIDL используется для описания COM-классов, интерфейсов и методов. Он аналогичен OMB/CORBA IDL по имени, синтаксису и назначению. Однако Java-программистам не обязательно использовать MIDL. В дальнейшем будет рассмотрено другое средство Microsoft, которое способно читать Java-классы и генерировать типовую библиотеку.

##### 3. COM:HRESULT функции возврата кодаФункции COM, представленные сервером, возвращают значение типа HRESULT, которое заранее определено. HRESULT представляет собой целое число, содержащее три поля. Это позволяет использовать множество кодов ошибок и успешных операций, а также другие данные. Поскольку COM-функции возвращают HRESULT, они не могут вернуть первоначальные данные через значения возврата. Если требуется вернуть данные, можно передать указатель на область памяти, где функция заполнит эти данные. Такие параметры называются "внешними". Как Java/COM-разработчики, нам не нужно сильно беспокоиться об этом вопросе, поскольку виртуальная машина автоматически управляет всем этим. Этот вопрос будет более подробно рассмотрен в последующих разделах.### А.5.2 Интеграция MS Java/COM

Данный текст уже на русском языке и требует минимальных изменений. Вот исправленный вариант:

### А.5.2 Интеграция MS Java/COMПо сравнению с C++/COM-разработчиками, Microsoft Java-компилятор, виртуальная машина и различные средства существенно упрощают работу Java/COM-разработчиков. Компилятор имеет специальные команды и пакеты, позволяющие рассматривать Java-классы как COM-классы. Однако в большинстве случаев мы можем полагаться на поддержку COM, предоставляемую Microsoft JVM, а также использовать два мощных внешних средства. Microsoft Java Virtual Machine (JVM) играет роль моста между объектами COM и Java. Если создать Java объект как COM сервер, то наш объект всё ещё будет выполняться внутри JVM. Microsoft JVM реализован в виде DLL, которая представляет COM интерфейсы операционной системе. Внутри JVM вызовы функций COM интерфейсов преобразуются в вызовы методов Java объектов. Конечно, JVM должна знать, какой Java class file соответствует модулю выполнения сервера; эта информация доступна благодаря тому, что мы заранее зарегистрировали class files с помощью `Javareg` в реестре Windows. `Javareg` — это утилита, предоставляемая вместе с Microsoft Java SDK, которая может прочитать Java class file, сгенерировать соответствующую типовую библиотеку и GUID, а также зарегистрировать класс в системе. Также можно использовать `Javareg` для регистрации удалённых серверов. Например, его можно использовать для регистрации сервера, работающего на другой машине. Если вы хотите создать Java/COM-клиента, вам потребуется пройти через ряд различных шагов.Java/COM "клиент" — это специальное Java-кодирование, которое хочет активировать и использовать COM-сервер, зарегистрированный в системе. Также виртуальная машина будет взаимодействовать с COM-сервером и представит его услуги как различные методы внутри Java-класса. Другой инструмент от Microsoft называется `jactivex`, который может прочитать библиотеку типов и сгенерировать соответствующие Java-источники, содержащие специальные команды компилятора. Генерируемые источники являются частью пакета, названного нами после указания типа библиотеки. Следующий шаг — импортирование этого пакета в собственные Java-источники клиента.Давайте рассмотрим два примера.

### А.5.3 Создание COM-сервера на Java

Этот раздел представляет процесс создания ActiveX-компонентов, серверов Automation или любого другого сервера, соответствующих стандартам COM. В этом примере реализован простой сервер Automation, который выполняет сложение целых чисел. Мы используем метод `setAddend()` для установки значения `addend`. Каждый раз при вызове метода `sum()`, значение `addend` добавляется к текущему значению `result`. Мы используем метод `getResult()` для получения значения `result` и метод `clear()` для сброса значений. Реализация поведения данного Java-класса очень проста:

```java
public class Adder {
  private int addend;
  private int result;

  public void setAddend(int a) { this.addend = a; }

  public int getAddend() { return this.addend; }

  public int getResult() { return this.result; }

  public void sum() { this.result += this.addend; }

  public void clear() {
    this.result = 0;
    this.addend = 0;
  }
}

Инструмент `Javareg` также регистрирует новый сервер в реестре Windows. На данном этапе важно помнить, что файл `Adder.class` должен быть скопирован в каталог `Windows\Java\trustlib`. Из соображений безопасности (особенно при вызовах COM-служб программными фрагментами), эти серверы будут активированы только после того, как они будут установлены в каталог `trustlib`. Теперь мы успешно установили новый сервер автоматизации в нашей системе. Для тестирования нам необходим контроллер автоматизации, который представляет собой Visual Basic (VB). Ниже приведены несколько строк кода VB. В соответствии с форматом VB я создал текстовое поле для получения значений от пользователя, которые требуется сложить, и метку для отображения результата. Два кнопочных элемента используются для вызова методов `sum()` и `clear()`. В начале мы объявляем объектную переменную `Adder`. В процедуре `Form_Load` (при первой загрузке формы) создаётся новый экземпляр сервера автоматизации `Adder`, и поля формы инициализируются значениями. Как только пользователь нажимает кнопки "Сумма" или "Очистка", соответствующие методы вызываются на стороне сервера.```vb
	Dim Adder As Object
	
	Private Sub Form_Load()
	    Set Adder = CreateObject("JavaAdder.Adder.1")
	    Addend.Text = Adder.GetAddend
	    Result.Caption = Adder.GetResult
	End Sub
	
	Private Sub SumBtn_Click()
	    Adder.SetAddend (Addend.Text)
	    Adder.Sum
	    Result.Caption = Adder.GetResult
	End Sub
	
	Private Sub ClearBtn_Click()
	    Adder.Clear
	    Addend.Text = Adder.GetAddend
	    Result.Caption = Adder.GetResult
	End Sub
```Обратите внимание, что этот код совершенно не знает, что сервер реализован на Java.

При запуске этого приложения и выполнении функции `CreateObject()`, Windows реестр будет проверять указанный ProgID. Самое важное в информации, связанной с этим ProgID, — это имя Java-класса. В ответ на это запускается Java Virtual Machine (JVM), которая затем вызывает экземпляр Java-объекта внутри JVM. С этого момента JVM автоматически управляет взаимодействием между клиентским и серверным кодами.

### А.5.4 Разработка COM-клиента на JavaТеперь давайте перейдем к другой стороне и разработаем COM-клиента на Java. Этот программный модуль будет использовать службы, установленные в системе COM-сервера. В данном примере мы используем клиента, который был создан для сервера в предыдущем примере. Несмотря на то, что код может показаться знакомым для Java-разработчика, происходящее за кулисами является необычным. В этом примере используется сервер, написанный на Java, но он применим ко всем ActiveX-компонентам, ActiveX Automation-серверам или ActiveX-компонентам, установленным в системе, если у нас есть типовая библиотека.
Сначала мы применяем инструмент `Jactivex` к типовой библиотеке сервера. У `Jactivex` есть ряд опций и ключей для выбора. Однако в его самом базовом виде он читает типовую библиотеку и генерирует Java-файлы источника. Этот источник сохраняется в нашем каталоге `windows/java/trustlib`. В следующей команде он применяется к типовой библиотеке, сгенерированной для внешнего COM Automation сервера:```bash
/path/to/Jactivex /path/to/typeLibrary.tlb -o windows/java/trustlib

Jactivex C:\external\comAutomation\types.tlb -o windows/java/trustlib

jactivex /javatlb JavaAdder.tlb

import javaadder.*;

public class JavaClient {
  public static void main(String [] args) {
    Adder_DispatchDefault iAdder = 
         (Adder_DispatchDefault) new Adder();
    iAdder.setAddend(3);
    iAdder.sum();
    iAdder.sum();
    iAdder.sum();
    System.out.println(iAdder.getResult());
  }
}

module RemoteTime {
   interface ExactTime {
      string getTime();
   };
};

idltojava -fserver -fclient RemoteTime.idl

```md
## Реализация удаленного приложения
```java
public class RemoteTimeServer {
  public static void main(String args[]) {
    try {
      // Создание и инициализация ORB:
      ORB orb = ORB.init(args, null);
      // Создаем объект сервера и регистрируем его:
      ExactTimeServer timeServerObjRef = new ExactTimeServer();
      orb.connect(timeServerObjRef);
      // Получаем корневой контекст именования:
      org.omg.CORBA.Object objRef = orb.resolve_initial_references("NameService");
      NamingContext ncRef = NamingContextHelper.narrow(objRef);
      // Привязываем строковое имя к объекту:
      NameComponent nc = new NameComponent("ExactTime", "");
      NameComponent path[] = {nc};
      ncRef.rebind(path, timeServerObjRef);
      // Ожидаем запросов от клиентов:
      java.lang.Object sync = new java.lang.Object();
      synchronized(sync) {
        sync.wait();
      }
    } catch (Exception e) {
      System.out.println("Ошибка сервера времени: " + e);
      e.printStackTrace(System.out);
    }
  }
}

import RemoteTime.*;
import org.omg.CosNaming.*;
import org.omg.CORBA.*;

public class RemoteTimeClient {
  public static void main(String args[]) {
    try {
      // Создание и инициализация ORB:
      ORB orb = ORB.init(args, null);
      // Получение корневого контекста именования:
      org.omg.CORBA.Object objRef =
        orb.resolve_initial_references(
          "NameService");
      NamingContext ncRef =
        NamingContextHelper.narrow(objRef);
      // Получение (разрешение) строкового представления ссылки на объект времени:
      NameComponent nc =
        new NameComponent("ExactTime", "");
      NameComponent path[] = {nc};
      ExactTime timeObjRef =
        ExactTimeHelper.narrow(
          ncRef.resolve(path));
      // Вызов запросов к служебному объекту:
      String exactTime = timeObjRef.getTime();
      System.out.println(exactTime);
    } catch (Exception e) {
      System.out.println(
         "Ошибка сервера удаленного времени: " + e);
      e.printStackTrace(System.out);
    }
  }
}
```Первые строки выполняют ту же работу, что и они выполняли в серверном процессе: ORB получает инициализацию, а затем разрешает ссылку на службу именования.
Затем нам требуется ссылка на служебный объект, поэтому мы передаем строковое представление ссылки непосредственно методу `resolve()`. Затем используем метод `narrow()` для преобразования результата в ссылку на интерфейс `ExactTime`. Наконец, вызываем метод `getTime()`.

##### 5. Активация процесса службы именТеперь, когда мы имеем отдельный сервер и клиентское приложение, они готовы к взаимной коммуникации. Оба они требуют использования службы имен для привязки и анализа строковых объектных ссылок. Перед запуском сервиса или клиента нам необходимо активировать процесс службы имен. В JavaIDL служба имен представляет собой Java-приложение, которое входит в состав продукта. Однако она может отличаться от аналогичных служб других продуктов. Процесс службы имен в JavaIDL работает в экземпляре JVM и (по умолчанию) мониторит сетевой порт  Yöntem 900.

##### 6. Активация сервера и клиента

Теперь мы можем запустить серверное и клиентское приложение (в указанном порядке, так как существование сервера является временным). При правильной настройке все должно работать корректно, что будет видно по одной строке вывода в окне консоли клиента, которая покажет текущее время. Конечно, сам этот результат не особенно впечатляет. Но стоит обратить внимание на то, что даже находясь на одном компьютере, клиентское и серверное приложения выполняются в разных виртуальных машинах. Между ними происходит коммуникация через базовый слой интеграции — ORB и службу имен.

---

Исправленный текст:

Теперь, когда мы имеем отдельный сервер и клиентское приложение, они готовы к взаимной коммуникации. Оба они требуют использования службы имен для привязки и анализа строковых объектных ссылок. Перед запуском сервиса или клиента нам необходимо активировать процесс службы имен. В JavaIDL служба имен представляет собой Java-приложение, которое входит в состав продукта. Однако она может отличаться от аналогичных служб других продуктов. Процесс службы имен в JavaIDL работает в экземпляре JVM и (по умолчанию) мониторит сетевой порт 900.

##### 6. Активация сервера и клиента

Теперь мы можем запустить серверное и клиентское приложение (в указанном порядке, так как существование сервера является временным). При правильной настройке все должно работать корректно, что будет видно по одной строке вывода в окне консоли клиента, которая покажет текущее время. Конечно, сам этот результат не особенно впечатляет. Но стоит обратить внимание на то, что даже находясь на одном компьютере, клиентское и серверное приложения выполняются в разных виртуальных машинах. Между ними происходит коммуникация через базовый слой интеграции — ORB и службу имен.Это всего лишь простой пример, предназначенный для работы в локальной сети. Однако обычно ORB настраивается таким образом, чтобы обеспечивать "независимость от местоположения". Если сервер и клиент расположены на разных машинах, то ORB использует компонент, называемый "репозиторием реализации", для анализа удалённых строковых ссылок. Хотя "репозиторий реализации" является частью CORBA, его конкретные спецификации не установлены, поэтому реализация этого компонента различается между производителями.Как вы можете заметить, есть много аспектов CORBA, которые не были подробно рассмотрены здесь. Тем не менее, надеюсь, что данное описание дало вам общее представление о CORBA. Для получения более подробной информации о CORBA лучшим источником являются официальные сайты OMG, доступные по адресу `http://www.omg.org`. Этот сайт предоставляет множество документов, белых страниц, программ и ссылок на другие ресурсы и продукты CORBA.

### A.6.3 Java апплеты и CORBA

Java апплеты могут выполнять роль клиента CORBA. Таким образом, апплеты могут получать доступ к удаленным данным и услугам, предоставленным объектами CORBA. Однако апплеты могут связываться только с тем сервером, который первоначально загрузил их, поэтому все объекты CORBA, с которыми апплеты взаимодействуют, должны располагаться на этом сервере. Это противоречит основной идеологии CORBA, которая обещает "независимость от местоположения" или "независимость от расположения". Использование Java программы как клиента CORBA также может вызвать некоторые проблемы безопасности. Если вы работаете в локальной сети, одним из решений может быть снижение уровня безопасности браузера. В качестве альтернативы можно использовать прокси-сервер для обеспечения безопасной связи с внешними серверами.По этому вопросу некоторые продукты Java ORB предлагают свои решения. Например, некоторые реализуют технологию, известную как "HTTP-туннелирование" (HTTP Tunneling), другие предоставляют специальные возможности для работы с прокси-серверами.Как часть приложения, все эти темы кажутся слишком сложными для простого понимания. Однако они действительно являются важными моментами для рассмотрения.

### А.6.4 Сравнение CORBA и RMI

Мы уже знаем, что одной из ключевых особенностей CORBA является поддержка удалённых вызовов процедур (RPC). Эта технология позволяет нашим локальным объектам вызывать методы удалённых объектов. Конечно, существует встроенная возможность Java — RMI (см. главу 15) — которая делает то же самое. Хотя RMI позволяет Java объектам вызывать RPC друг у друга, CORBA способна выполнять RPC между объектами, написанными на любом языке. Это явно большая разница.

Однако через RMI можно вызывать службы, использующие удалённый, не-Java код. Для этого нам требуется некоторый вид упакованного Java объекта на стороне сервера, который "обёртывает" этот не-Java код. Упакованный объект связывается с Java клиентом через RMI и внутри него создаёт соединение с не-Java кодом — с помощью технологии, такой как JNI или J/Direct.

При использовании такого подхода мы должны создать некоторую форму "интеграционного слоя". На самом деле это именно то, что CORBA делает за нас. Но после этого больше нет необходимости использовать ORB от других производителей.

## А.7 ЗаключениеВ этом приложении мы рассматриваем самые базовые техники для вызова не-Java кода из Java приложений. Каждая из этих техник имеет свои преимущества и недостатки. Однако основная проблема заключается в том, что не все эти возможности доступны во всех JVM. Поэтому даже если Java программа может вызывать встроенные методы на конкретной платформе, она может не работать на другой платформе с другой JVM. Компания Sun предоставляет JNI, которая характеризуется гибкостью, простотой (хотя она требует значительного контроля над ядром JVM) и мощностью, а также универсальностью для большинства JVM. На момент окончания работы над этой книгой Microsoft всё ещё не предоставлял поддержки JNI, вместо этого предлагая свой J/Direct (удобный способ вызова Win32 DLL функций) и RNI (особенно подходящий для написания эффективного кода, но требующий глубокого понимания ядра JVM). Microsoft также предлагает своё патентованное решение для интеграции Java с COM. Это решение обладает большой мощностью и делает Java эффективным языком для написания COM серверов и клиентов. Только компиляторы и JVM от компании Microsoft поддерживают J/Direct, RNI и Java/COM. Последним, что мы рассмотрели, является CORBA, который позволяет нашим объектам на Java взаимодействовать с другими объектами — независимо от их местоположения и языка реализации.CORBA отличается от всех ранее упомянутых технологий тем, что он не интегрирован в язык Java, а использует технологии других производителей (третьих сторон) и требует покупки ORB от этих производителей. CORBA представляет собой интересное и универсальное решение, но если вам требуется просто вызывать операции системы, это может не считаться оптимальным решением.