Study & Dev | Blog Archive | Hessian связывает flash и java

Hessian связывает flash и java

February 7, 2008

Введение

Если вы занимаетесь разработкой flash-приложений, которые взаимодействуют с сервером, то ваш выбор вовсе не ограничен xml и amf, как единственными доступными форматами для пересылки данных. Выбор между этими двумя стратегиями (текстовые форматы данных против двоичных) не всегда прост. На одной чаше весов находится небольшой размер файла (xml-файлы бывают ужасно громоздки), также операция сохранения actionscript объекта в xml-документ и обратная ему операция восстановления могут быть слишком медленными и требовать значительных затрат памяти. На второй чаше весов до недавних пор находилась гипотетическая свобода: до конца 2007 г. формат amf был закрыт и не были доступны официальные спецификации формата. Конечно, это не мешало появлению множества библиотек для java, php, ruby … которые умели формировать и читать amf-поток данных (хотя оставался неприятный привкус). А при условии грамотной реализации server-side и четкого отделения слоя занимающегося чтением или записью amf-данных от остальных частей приложения (бизнес логика, работа с СУБД …), может исчезнуть и такой “гипотетически неправильный” фактор, как смена средства для представления данных (ну вы знаете эту сказку про то, что сегодня мы делаем для flash, а завтра для silverlight, а послезавтра …). Ну а историю о том, что amf-основанные приложения трудно отлаживать т.к. не нельзя посмотреть глазками на то, какие данные идут от сервера к клиенту или наоборот, я оставляю в качестве утешения тем, кто ни разу не встречался с charles (http://xk72.com).

Естественно, что вакуум, образовавшийся в сфере “с помощью чего же нам послать данные на сервер”, не мог быть замечен рядом коммерческих (и не очень) организаций и они поспешили предоставить собственные продукты, которые “быстрее, выше и дальше”. Сегодня я расскажу об Hessian – двоичном протоколе для общения между клиентом и сервером. Hessian был разработан компанией caucho (http://hessian.caucho.com/index.xtp). Для тех, кто не знает, это автор одного из наиболее популярных java-серверов resin. Упреждая вопросы, естественно, что caucho не могли сделать ошибки и жестко привязать Hessian только к их серверу. Фактически сам код библиотеки это небольшой архив jar размером чуть менее 300 кб (и никаких внешних зависимостей). Код показанного примера я писал под tomcat 6.0.14 и перед размещением в internet проверил под jetty6 – все работало без проблем.

Надо сказать, что caucho разработала также и смежный с Hessian протокол Burlap (он в отличии от Hessian основан на xml), но какого-то глубокого смысла в использовании еще одного велосипеда я не нашел, к тому же поддержки сериализации flash-структур данных в этот формат в составе найденного на сайте caucho flash-клиента не было. К слову о клиенте Hessian, помимо flash версии библиотеки, есть и реализация Hessian для приложений построенных на базе javaFX.

Какие есть реализации Hessian на стороне сервера?

Естественно есть реализация для java (на ее примере я и буду дальше показывать, как создать Hessian-сервис). Надо сказать, что именно с java-реализацией я познакомился пару лет назад и использовал как альтернативу построения веб-сервисов между java-java (в условиях “закрытости” сервиса, особый бинарный формат Hessian был не существенен, а поддержка передачи сложных структур данных у него на высоте).

Есть и реализация hessian для php http://hessianphp.sourceforge.net/index.html. Библиотека развивалась в промежутке между 2004 и 2005 годами, с тех пор каких-либо значимых анонсов я не заметил. С другой стороны несколько тестовых приложений, которые я попробовал сделать в рамках изучения и ознакомления, работали без проблем.

С ruby и C# я никогда не работал, так что приведу просто ссылку на сайты соответствующих проектов (http://sourceforge.net/projects/hessianruby/ и http://www.hessiancsharp.org/). Возможно, там найдется и поддержка создания клиента для silverlight, но спекулировать на эту тему я не буду.

Далее я покажу пример создания на базе Hessian небольшого сервиса реализующего … да ничего не реализующего. Я полагаю, что читающие эту заметку вдоволь насмотрелись на мини-калькуляторы, мини-проверялки орфографии и т.д. Сервис должен передавать сложную структуру данных, java-сервис должен его получать, имитировать обработку и после изменения, отправить изменения обратно flash-клиенту.

Сначала вам нужно загрузить с сайта http://hessian.caucho.com/index.xtp свежую версию библиотеку для java стороны сервиса (я писал данный пример на основе hessian-3.1.3.jar от 2007.10.07, объем 144k), также flash библиотеку (я использовал hessian-flash-3.1.2.swc, объем 152k). Там же, на сайте, доступны их исходники.

Структуры данных на стороне java

```
/**
```

 * Объект элемент записной книжки

```
 */
```

public class Note implements Serializable {

```
    public Integer id;
```
```
    public String message;
```
```
    public Document comments;
```
```
 
```

    public Note(Integer _id, String _message, Document _comments) {

```
        this.id = _id;
```
```
        this.message = _message;
```
```
        this.comments = _comments;
```
```
    }
```
```
}
```
```
 
```
```
 
```
```
/**
```

 * Объект событие привязанное к некоторой записи в записной книжке

```
 */
```

public class NoteEvent implements Serializable {

```
    public String message;
```
```
    public Date dateof;
```
```
    public Note friendNote;
```
```
 
```

    public NoteEvent(String _message, Date _dateof, Note _friendNote) {

```
        this.message = _message;
```
```
        this.dateof = _dateof;
```
```
        this.friendNote = _friendNote;
```
```
    }
```
```
}
```
```
 
```
```
 
```
```
/**
```

 * Улучшенная заметка для записной книжки, добавлена поддержка "связанного" списка событий

```
 */
```

public class SuperNote extends Note implements Serializable {

```
    public ArrayList<NoteEvent> events;
```
```
 
```

    public SuperNote(Integer _id, String _message, Document _comments, ArrayList<NoteEvent> _events) {

        super(_id, _message, _comments);

```
        this.events = _events;
```
```
    }
```
```
}
```
```
 
```
```
 
```
```
/**
```

 * Объект записная книжка

```
 */
```

public class Notebook implements Serializable {

```
    public ArrayList<Note> notes;
```
```
 
```

    public Notebook(ArrayList<Note> _notes) {

```
        this.notes = _notes;
```
```
    }
```
```
}
```

Объект Notebook является контейнером для массива записей (Note или SuperNote). SuperNote производная от Note и добавляет (помимо простых полей своего предка) еще один контейнер для хранения событий привязанных к этой "Супер записи". Каждое событие (представлено классом NoteEvent) может содержать ссылку на еще один объект Note.

Особых ограничений на используемые типы данных hessian не накладывает. Так часть полей у меня “почти примитивы” (String, Integer), есть и более сложные (ArrayList) и объект XML Document. Важно, чтобы все типы данных, которые мы хотим передавать по сети, реализовывали интерфейс Serializable.

Теперь нужно разработать типы данных на стороне actionscript. Я создам те же четыре класса, помещу их в такой же пакет, как и java-код (model). Ну а говорить о том, что имена классов, имена полей совпадают, пожалуй не стоит – это очевидно (точнее "правильнее", хотя и не обязательно, далее я скажу об этом подробнее). Кода java-сервис выполняет отправку данных к flash-клиенту, то он отправляет вместе с данными и имена типов данных, на основании этих имен выполняется восстановление структуры.

Если два объекта, между которыми должна выполняться синхронизация, имеют “почти примитивный” тип данных (число, строка, массив), то проблем при передаче не возникает. Однако что будет в случае использования чего-то посложнее, чем строка или число? Как работает механизм чтения данных? Прочитав из потока информацию об объекта Hessian ищет тип данных с таким же названием как и передан с той стороны (благодаря одинаковому названию model.Note в java перейдет без проблем в model.Note в hessian). Но, если тип данных на стороне java или flash не был найден, то он заменяется на наиболее общий тип: для стороны java это объект HashMap (ассоциативный массив), для стороны flash – Object (с динамическим созданием полей с такими же именами, как были переданы).

Относительно того, что нет возможности полного преобразования между java и actionscript объектами, то больших проблем в этом я не нашел. С одной стороны завязывать код клиентского приложения на те структуры данных, которые возвращает сервис, не самая лучшая идея: это снижает гибкость приложения в ситуации когда “йо, мы забыли самое важное и теперь придется переделать структуру данных, передаваемую по сети”. Так что я всегда выделял отдельный код, который полученные структуры данных из java-сервиса конвертировал в actionscript-объекты (используемые для работы внутри приложения) и, наоборот. В любом случае выполнять подобные преобразования можно только в самом общем случае и при использовании чего-то сложнее(id, fio, birthday) придется “поработать напильником” (в конце-концов, это ведь два разных языка).

Как вывод: для передачи данных по сети необходимо тщательно очистить передаваемые классы от всего лишнего, заменить все нетривиальные типы данных на собственные аналоги.

Примеры actionscript-классов

```
package model
```
```
{
```
```
  public class Note
```
```
  {
```

        // явное указание на тип данных который находится на той строне

	public var hessianTypeName : String = "model.Note";

```
 
```

	// все поля которые мы хотим получить из java-сервиса должны быть public

	public var secret : String = "Супер-секрет о Flex";

```
	public var id : int;
```
```
	public var message : String;
```
```
	public var comments : Object;
```
```
 
```
```
 
```

	// всем классам которые будут передаваться по сети необходимо иметь конструктор без параметров

```
	public function Note (){}
```
```
 
```

	public function __initNote(_id: int, _message: String, _comments: Object):void{

```
		this.id = _id;
```
```
		this.message = _message;
```
```
		this.comments = _comments;
```
```
	}
```
```
  }
```
```
}
```
```
 
```
```
package model
```
```
{
```
```
 
```
```
  public class SuperNote extends Note
```
```
  {
```
```
 
```

	public var events : Array = new Array ();

```
 
```

        // явное указание на тип данных который находится на той строне

```
	public function SuperNote (){
```
```
		hessianTypeName = "model.SuperNote";
```
```
	}
```
```
 
```

	public function __initSuperNote (_id: int, _message: String, _comments: Object, _events: Array):void{

		super.__initNote(_id,_message,_comments);

```
		events = _events;
```
```
	}
```
```
  }
```
```
}
```
```
 
```
```
package model
```
```
{
```
```
  public class NoteEvent
```
```
  {
```

        // явное указание на тип данных который находится на той строне

	public var hessianTypeName : String = "model.NoteEvent";

```
 
```
```
	public var message : String;
```
```
	public var dateof : Object;
```
```
	public var friendNote : Note;
```
```
 
```
```
	public function NoteEvent (){}
```
```
 
```

	public function __initNoteEvent (_message: String, _dateof: Object, _friendNote : Note):void{

```
		this.message =_message;
```
```
		this.dateof = _dateof;
```
```
		this.friendNote = _friendNote;
```
```
	}
```
```
  }
```
```
}
```
```
 
```
```
package model
```
```
{
```

  import mx.collections.ArrayCollection;

```
 
```
```
  public class Notebook
```
```
  {
```

        // явное указание на тип данных который находится на той строне

	public var hessianTypeName : String = "model.Notebook";

```
 
```

	public var notes : Array = new Array();

```
	public function Notebook (){}
```
```
 
```

	public function __initNotebook(_notes: Array):void{

```
		this.notes = _notes;
```
```
	}		
```
```
  }
```
```
}
```

Обратите внимание на то, что тип данных для поля comments объекта Note имеет тип Object (никаких возможностей автоматически преобразовать xml в стиле java в xml в стиле actionscript, как я раньше и подчеркивал, нет). Да знаю я, знаю, это надуманный пример.

Также если в java-классе есть поля с модификаторами private то они все равно будут посланы по сети, а вот обратное не верно из flash уйдут на сервер только те поля, которые имеют модификатор public. В общем, подгоняем структуры данных и по модификаторам иначе операция чтения с последующим присвоением полей в flash-клиенте будет неудачной.

Критически важно: при передаче данных по сети для операции автоматического преобразования типов данных используются их имена, однако при передаче между flash и java. Возможны проблемы из-за того, что метод получения полностью квалифицированного имени класса в java возвращает имя в стиле пакет1.подпакет1.класс1, в то время как в flash в качестве разделителей имени класса и пакета выступает символ "::". Естественно, что выполнить такое преобразование не возможно (надо сказать что несколько раз я замечал как приходили имена от flash в стиле java, объяснения причины такому поведению у меня нет). В любом случае есть рекомендованная методика подсказки: если добавить в класс строкое поле с именем hessianTypeName и указать ему имя класса java на той строне, то все будет работать как часы.

Создаем java-сервис

Для создания сервиса, прежде всего, необходимо определить интерфейс с перечислением методов, которые мы хотим сделать “доступными”. Например:

```
public interface ILifeSupport {
```

    Notebook doAnything (String whatDoYourWant, Notebook notebook) throws ServletException, MegaException;

    String reverseString(String strForReverse);

```
}
```

В составе интерфейса два метода: простенький reverseString (строка на вход и строка на выход) и более сложный doAnything, получающий два параметра один из которых объект Notebook.

Теперь нужно написать код сервлета, реализующего данную функциональность. В следующем примере я создал свой класс сервлет, как наследник от HessianServlet, но в случае необходимости и этого требования можно избежать.

```
package helpers;
```
```
 
```

import com.caucho.hessian.server.HessianServlet;

```
import model.Note;
```
```
import model.NoteEvent;
```
```
import model.Notebook;
```
```
import model.SuperNote;
```
```
import org.w3c.dom.Document;
```
```
import org.w3c.dom.Element;
```
```
 
```
```
import javax.servlet.ServletConfig;
```
```
import javax.servlet.ServletException;
```

import javax.xml.parsers.DocumentBuilder;

import javax.xml.parsers.DocumentBuilderFactory;

import javax.xml.parsers.ParserConfigurationException;

```
import java.util.ArrayList;
```
```
import java.util.Date;
```
```
 
```
```
 
```

public class NotebookServerImpl extends HessianServlet implements ILifeSupport {

```
 
```

    public void init(ServletConfig servletConfig) throws ServletException {

```
        super.init(servletConfig);
```
```
    }
```
```
 
```
```
 
```
```
    /**
```

     * Метод, который выполняет какую-то важную задачу улучшения жизни

```
     *
```

     * @param whatDoYourWant Запрос на то что мы хотим улучшить

     * @param notebook       Содержимое записной книжки желающего улучшений

     * @return Улучшенная записная книжка

```
     */
```

    public Notebook doAnything(String whatDoYourWant, Notebook notebook) throws ServletException, MegaException {

        if (whatDoYourWant.indexOf("Счастье") >= 0)

            throw new IllegalArgumentException("Счастья нет");

        if (whatDoYourWant.indexOf("Горе") >= 0)

            throw new MegaException("И горя тоже нет");

```
 
```
```
 
```
```
        DocumentBuilder builder = null;
```
```
        try {
```

            builder = DocumentBuilderFactory.newInstance().newDocumentBuilder();

```
        }
```

        catch (ParserConfigurationException ce) {

            throw new ServletException(ce);

```
        }
```
```
        // -- start build xml
```

        Document doc = builder.newDocument();

        final Element megaroot = doc.createElement("MegaRoot");

        final Element simplenode = doc.createElement("SimpleNode");

```
        doc.appendChild(megaroot);
```

        simplenode.setAttribute("IsHappy", "Да");

        megaroot.appendChild(doc.createCDATASection("Основы экономики"));

        megaroot.appendChild(simplenode);

```
        // -- end build xml
```
```
 
```

        ArrayList<Note> notes = new ArrayList<Note>();

        final Note note_lenka = new Note(1, "Привет, Ленка", doc);

```
        notes.add(note_lenka);
```
```
 
```

        ArrayList<NoteEvent> events = new ArrayList<NoteEvent>();

        // у элемента NoteEvent есть ссылка на запись Note принадлежащую Ленке

        final NoteEvent note_tanka = new NoteEvent("Купить чайник", new Date(), note_lenka);

```
        events.add(note_tanka);
```

        notes.add(new SuperNote(2, "Привет, Танька", doc, events));

```
        return new Notebook(notes);
```
```
    }
```
```
 
```
```
 
```

    public String reverseString(String strForReverse) {

        // переворачивание строки, я только сейчас понял, что у java нет метода reverse для строки,

        // нужно создавать StringBuffer, как это ужасно

        StringBuffer buf = new StringBuffer(strForReverse);

        return buf.reverse().toString();

```
    }
```
```
}
```

В дескриптор развертывания я добавил маппинг для созданного выше сервлета:

```
<?xml version="1.0" encoding="UTF-8"?>
```

<web-app version="2.5" xmlns="http://java.sun.com/xml/ns/javaee"

xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

xsi:schemaLocation="http://java.sun.com/xml/ns/javaee

http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd">

```
    <servlet>
```

        <servlet-name>NotebookServer</servlet-name>

        <servlet-class>helpers.NotebookServerImpl</servlet-class>

```
    </servlet>
```
```
 
```
```
    <servlet-mapping>
```

        <servlet-name>NotebookServer</servlet-name>

        <url-pattern>/hessian/notes/*</url-pattern>

```
    </servlet-mapping>
```
```
</web-app>
```

Далее я покажу пример связывания между java-java. Чтобы показать, что мы можем корректно передавать не только сложные структуры данных, но и корректно обрабатываются выброшенные исключения я задекларировал две исключительные ситуации (IllegalArgumentException, MegaException). Они бросаются, если в первом параметре метода doAnything переданы строки содержащие слова “Счастье” и “Горе” (во втором случае бросается пользовательское исключение).

public class MegaException extends Exception{

    public MegaException(String message) {

```
        super(message);
```
```
    }
```
```
}
```

Тестируем созданный сервис, пока из java-клиента

Теперь пример кода, который тестирует работу сервиса (java -> java). В практике это неплохой вариант: сначала протестировать функциональность проекта, используя для вызова java-клиент, а затем переносить код на flash-клиента.

```
package test;
```
```
 
```

import com.caucho.hessian.client.HessianProxyFactory;

```
import helpers.ILifeSupport;
```
```
import helpers.MegaException;
```
```
import model.Note;
```
```
import model.NoteEvent;
```
```
import model.Notebook;
```
```
import model.SuperNote;
```
```
import static org.junit.Assert.*;
```
```
import org.junit.BeforeClass;
```
```
import org.junit.Test;
```
```
import org.w3c.dom.Document;
```
```
import org.w3c.dom.Element;
```
```
 
```
```
import javax.servlet.ServletException;
```

import javax.xml.parsers.DocumentBuilder;

import javax.xml.parsers.DocumentBuilderFactory;

import javax.xml.parsers.ParserConfigurationException;

```
import java.net.MalformedURLException;
```
```
import java.util.ArrayList;
```
```
import java.util.Date;
```
```
 
```
```
 
```
```
public class TestService {
```
```
 
```
```
    private static ILifeSupport ilife;
```

    private static Notebook notebookDemo;

```
 
```
```
    @BeforeClass
```

    public static void setUp() throws MalformedURLException, ParserConfigurationException {

        // выполняем подготовку класса для теста (создаем сервис подключенный к hessian,

        // а таккже заготовку объекта Notebook)

        String url = "http://center:8080/notes/hessian/notes";

```
 
```

        HessianProxyFactory factory = new HessianProxyFactory();

        // запросили создание сервиса располженного по адресу url и реализующего интерфейс ILifeSupport

        ilife = (ILifeSupport) factory.create(ILifeSupport.class, url);

```
 
```
```
        DocumentBuilder builder = null;
```

        builder = DocumentBuilderFactory.newInstance().newDocumentBuilder();

```
        // -- start build xml
```

        Document doc = builder.newDocument();

        final Element megaroot = doc.createElement("MegaRoot");

        final Element simplenode = doc.createElement("SimpleNode");

```
        doc.appendChild(megaroot);
```

        simplenode.setAttribute("IsHappy", "Да");

        megaroot.appendChild(doc.createCDATASection("Основы экономики"));

        megaroot.appendChild(simplenode);

```
        // -- end build xml
```
```
 
```

        Note note_vasya = new Note(1, "Заметки о Васе", doc);

        ArrayList<NoteEvent> events = new ArrayList<NoteEvent>();

        events.add(new NoteEvent("Сообщение об чем-то важном", new Date(), note_vasya));

        SuperNote note_petya = new SuperNote(2, "Заметки о Пете", doc, events);

```
 
```

        final ArrayList<Note> listNotes = new ArrayList<Note>();

```
        listNotes.add(note_vasya);
```
```
        listNotes.add(note_petya);
```

        notebookDemo = new Notebook(listNotes);

```
    }
```
```
 
```
```
    @Test
```
```
    public void testSimpleString() {
```

        // тест на простенькое переворачивание строки

        assertEquals("яицативарГ", ilife.reverseString("Гравитация"));

```
    }
```
```
 
```
```
    @Test
```

    public void testReferences() throws MegaException, ServletException {

        // проверка на то что корректно передаются рекурсивные структуры данных

        Notebook book = ilife.doAnything("Слоники на водопаде", notebookDemo);

        SuperNote snote = (SuperNote) book.notes.get(1);

        assertSame(snote.events.get(0).friendNote, book.notes.get(0));

```
    }
```
```
 
```
```
 
```
```
    @Test
```

    public void testNotebookService() throws ServletException, MegaException {

        // проверка полученного объекта notebook, включает в себя тест по количество полученных записей в книжке

        Notebook book = ilife.doAnything("Слоники на водопаде", notebookDemo);

        assertEquals(book.notes.size(), 2);

        assertEquals(1, (long) book.notes.get(0).id);

        assertEquals(2, (long) book.notes.get(1).id);

        // также проверяем правильность передачи иерархии классов

        assertTrue(book.notes.get(1) instanceof SuperNote);

        final SuperNote snote = (SuperNote) book.notes.get(1);

        // и тестируем как передалось такое "тяжеловесное образование" как XML Document

        assertEquals("MegaRoot", snote.comments.getDocumentElement().getNodeName());

        assertEquals("SimpleNode", snote.comments.getDocumentElement().getLastChild().getNodeName());

```
        assertEquals("Да", 
```

          snote.comments.getDocumentElement().getLastChild().

          getAttributes().getNamedItem("IsHappy").getNodeValue());

```
    }
```
```
 
```
```
 
```

    @Test(expected = IllegalArgumentException.class)

    public void testNotebookServiceMustFail_1() throws ServletException, MegaException {

        // тест на выбрасывание исключения нужного типа

        Notebook book = ilife.doAnything("Счастье", notebookDemo);

```
        assertTrue(false);
```
```
    }
```
```
 
```

    @Test(expected = MegaException.class)

    public void testNotebookServiceMustFail_2() throws ServletException, MegaException {

        // еще один тест на выбрасывание исключения нужного типа

        Notebook book = ilife.doAnything("Горе", notebookDemo);

```
        assertTrue(false);
```
```
    }
```
```
}
```

Flex-клиент

Теперь переходим к flex и форму с кнопкой “послать” и текстовой надписью Label, в которую я буду выводить размер отправляемых данных полученных путем сериализации в ByteArray.

Какой-то особой обработки принятых данных я делать не буду: просто сделаю скриншот окна debugger-а, чтобы показать, во что превратились принятые данные.

Вот код клиента:

```
<?xml version="1.0" encoding="utf-8"?>
```

<mx:Application xmlns:mx="http://www.adobe.com/2006/mxml" layout="absolute"

```
	implements="mx.rpc.IResponder"
```

	applicationComplete="onAppCreationComplete ()"

```
	>
```
```
<mx:Script>
```
```
<![CDATA[
```
```
  import mx.events.ResizeEvent;
```
```
  import mx.rpc.events.ResultEvent;
```
```
  import model.NoteEvent;
```
```
  import model.SuperNote;
```
```
  import model.Note;
```
```
  import model.Notebook;
```
```
  import mx.rpc.AsyncToken;
```
```
  import mx.controls.Alert;
```
```
  import hessian.client.HessianService;
```
```
 
```
```
  private var service: HessianService;
```

  // ссылка на объект удаленного сервиса hessian

  private function onAppCreationComplete ():void{

	service = new HessianService ("http://center:8080/notes/hessian/notes");

        // создадим сервис указав как параметр путь к его реализации

```
  }
```
```
 
```

  public function fault(_evt:Object):void{

    // обработка ошибки при вызове удаленного сервиса

    mx.controls.Alert.show("fail: "+ _evt);

```
  }
```
```
 
```

  public function result(_evt:Object):void{

     // метод вызываемый при условии успешного завершения вызова

     var evt : ResultEvent  = _evt as ResultEvent;

     mx.controls.Alert.show("ok: "+evt.result + " : "+

     // сравним правильно ли была передана иерархия взаимосвязанных объектов

     // нет, не правильно. Объект-запись под номером 0 был восстановлена два раза.

     // Надо сказать что это поведение несколько не устойчиво, и пару раз восстановление проводилось успешно,

     // точной зависимости почему и как у меня. поэтому я решил полагаться на худшую ситуацию:

     // рекурсия корректно не обрабатывается.

     (evt.result.notes[1].events[0].friendNote == evt.result.notes[0])

```
     );
```
```
   }
```
```
 
```
```
   private function doSend ():void{
```
```
	var x : XML = 
```
```
	   <Special>
```
```
	      <Personal />
```
```
	      <User id="1" name="Jim" />
```

	      <Message>Привет, Джим</Message>

```
	   </Special>;
```
```
 
```

	   //всякая попытка передать сложную структуру данных

	   //(имеющую рекурсивые отношения) приводит к переполнению стека

	   var IF_MAKE_ERROR : Boolean = false;

```
	   if (! IF_MAKE_ERROR)
```
```
		x = null; 
```
```
 
```

	   var note_1 : SuperNote = new SuperNote ();

	   note_1.__initSuperNote(1, "Привет, Вася", x, []);

```
 
```
```
	   var note_2 : Note = new Note ();
```

	   note_2.__initNote(2, "Привет, Ленка", x);

```
 
```

	   var event_1 : NoteEvent = new NoteEvent();

	   event_1.__initNoteEvent('Привет, Петька', new Date (), IF_MAKE_ERROR?note_1:null);

```
	   note_1.events.push(event_1);
```
```
 
```

	   var notebook : Notebook = new Notebook ();

	   notebook.__initNotebook([note_1, note_2]);

```
 
```

	   //теперь оценим размер передаваемых данных:

	   var bout : ByteArray   = new ByteArray  ();

```
	   bout.writeObject(notebook);
```

	   lab_out_size.text =  ""+bout.length;

```
 
```

	   // делаем вызов (имя операции doAnything)

	   var token:AsyncToken =  service.doAnything.send("Запрос на улучшение жизни", notebook);

           // указываем объект отвественный за обработку событий (был ли успешен вызов или нет?)

```
	   token.addResponder(this);
```
```
   }
```
```
]]>
```
```
</mx:Script>
```
```
 
```

<mx:VBox width="100%" height="100%" paddingBottom="20" paddingLeft="20" paddingRight="20" paddingTop="20">

```
   <mx:HBox width="100%">
```

	<mx:Button label="Отправить набор данных" click="doSend ()" />

	<mx:Label text="Размер отправляемых данных: "/>

```
	<mx:Label id="lab_out_size"  />
```
```
   </mx:HBox>
```
```
</mx:VBox>
```
```
</mx:Application>
```

Обратите внимание на то, что добавлена переменная IF_MAKE_ERROR. В случае если ее значение true, то в отправляемую на сервер информацию добавляются данные “рекурсивной структуры”. Если так сделать, то Hessian увлекается спуском по стеку и генерируется исключение stack overflow.

Интересно, что и обратная операция восстановления рекурсивной структуры данных проходит не совсем хорошо: если в потоке пришло один объект на который есть две ссылки из других объектов, то при восстановлении будет создана вторая копия объекта. (см. метод result).

Вот так выглядит пример отправляемых по сети данных:

А вот так выглядят полученные данные на строне flash:

И пример полученных данных на строне java:

Обратите внимание на то, что тип данных дата был восстановлен корректно, также как и остальные "примитивные типы данных" (автоматически и без подсказок о правилах маппинга).

Categories: Flash & Flex

Study & DevО программировании и не только

Hessian связывает flash и java

Введение

Какие есть реализации Hessian на стороне сервера?

Структуры данных на стороне java

Примеры actionscript-классов

Создаем java-сервис

Тестируем созданный сервис, пока из java-клиента

Flex-клиент

Поиск

Недавнее

Архив

Разделы