Иллюстрированный самоучитель по Java

Архиватор jar

Для упаковки нескольких файлов в один архивный файл, со сжатием или без сжатия., в технологии Java разработан формат JAR. Имя архивного jar-файла может быть любым, но обычно оно получает расширение jar. Способ упаковки и сжатия основан на методе ZIP. Название JAR (Java ARchive) перекликается с названием известной утилиты TAR (Tape ARchive), разработанной в UNIX.
Отличие jar-файлов от zip-файлов только в том, что в первые автоматически включается каталог META-INF, содержащий несколько файлов с информацией об упакованных в архив файлах.
Архивные файлы очень удобно использовать в апплетах, поскольку весь архив загружается по сети сразу же, одним запросом. Все файлы апплета с байт-кодами, изображениями, звуковые файлы упаковываются в один или несколько архивов. Для их загрузки достаточно в теге указать имена архивов в параметре archive, например:
width = "100%" height = "100%">
Основной файл MillAnim.class должен находиться в каком-либо из архивных файлов first.jar или second.jar. Остальные файлы отыскиваются в архивных файлах, а если не найдены там, то на сервере, в том же каталоге, что и HTML-файл. Впрочем, файлы апплета можно упаковать и в zip-архив, со сжатием или без сжатия.
Архивные файлы удобно использовать и в приложениях (applications). Все файлы приложения упаковываются в архив, например, appl.jar. Приложение выполняется прямо из архива, интерпретатор запускается с параметром -jar, например:
Java -jar appl.jar
Имя основного класса приложения, содержащего метод main (), указывается в файле MANIFEST.MF, речь о котором пойдет чуть ниже.
Архивные файлы удобны и просты для компактного хранения всей необходимой для работы программы информации. С файлами архива можно работать прямо из архива, не распаковывая их, с помощью классов пакета
java.util.jar.

Что такое Java

Это остров Ява в Малайском архипелаге, территория Индонезии. Это сорт кофе, который любят пить создатели Java (произносится "Джава", с ударением на первом слоге). А если серьезно, то ответить на этот вопрос трудно, потому что границы Java, и без того размытые, все время расширяются. Сначала Java (официальный день рождения технологии Java — 23 мая 1995 г.) предназначалась для программирования бытовых электронных устройств, таких как телефоны. Потом Java стала применяться для программирования браузеров — появились
апплеты.
Затем оказалось, что на Java можно создавать полноценные приложения. Их графические элементы стали оформлять в виде компонентов — появились
JavaBeans, с
которыми Java вошла в мир распределенных систем и промежуточного программного обеспечения, тесно связавшись с технологией CORBA. Остался один шаг до программирования серверов — этот шаг был сделан — появились
сервлеты
и
EJB
(Enterprise JavaBeans). Серверы должны взаимодействовать с базами данных — появились драйверы JDBC (Java DataBase Connection). Взаимодействие оказалось удачным, и многие системы управления базами данных и даже операционные системы включили, Java в свое ядро, например Oracle, Linux, MacOS X, AIX. Что еще не охвачено? Назовите, и через полгода услышите, что Java уже вовсю применяется и там. Из-за этой размытости самого понятия его описывают таким же размытым словом —
технология.
Такое быстрое и широкое распространение технологии Java не в последнюю очередь связано с тем, что она использует новый, специально созданный язык программирования, который так и называется — язык Java. Этот язык создан на базе языков Smalltalk, Pascal, C++ и др., вобрав их лучшие, по мнению создателей, черты и отбросив худшие. На этот счет есть разные мнения, но бесспорно, что язык получился удобным для изучения, написанные на нем программы легко читаются и отлаживаются: первую программу можно написать уже через час после начала изучения языка. Язык Java становится языком обучения объектно-ориентированному программированию, так же, как язык Pascal был языком обучения структурному программированию. Недаром на Java уже написано огромное количество программ, библиотек классов, а собственный апплет не написал только уж совсем ленивый.

Для полноты картины следует сказать, что создавать приложения для технологии Java можно не только на языке Java, уже появились и другие языки, есть даже компиляторы с языков Pascal и C++, но лучше все-таки использовать язык Java; на нем все аспекты технологии излагаются проще и удобнее. По скромному мнению автора, язык Java будет использоваться для описания различных приемов объектно-ориентированного программирования так же, как для реализации алгоритмов применялся вначале язык Algol, а затем язык Pascal.

Ясно, что всю технологию Java нельзя изложить в одной книге, полное описание ее возможностей составит целую библиотеку. Эта книга посвящена только языку Java. Прочитав ее, вы сможете создавать Java-приложения любой сложности, свободно разбираться в литературе и листингах программ, продолжать изучение аспектов технологии Java по специальной литературе. Язык Java тоже очень бурно развивается, некоторые его методы объявляются устаревшими (deprecated), появляются новые конструкции, увеличивается встроенная библиотека классов, но есть устоявшееся .ядро языка, сохраняется его дух и стиль. Вот это-то устоявшееся и излагается в книге.

Что такое JDK

Набор программ и классов JDK содержит:
компилятор javac из исходного текста в байт-коды; интерпретатор java, содержащий реализацию JVM;
облегченный интерпретатор jre (в последних версиях отсутствует);
программу просмотра апплетов appietviewer, заменяющую браузер;
отладчик jdt>;
дизассемблер javap;
программу архивации и сжатия jar;
программу сбора документации javadoc;
программу javah генерации заголовочных файлов языка С;
программу javakey добавления электронной подписи;
программу native2ascii, преобразующую бинарные файлы в текстовые;
программы rmic и rmiregistry для работы с удаленными объектами;
программу seriaiver, определяющую номер версии класса;
библиотеки и заголовочные файлы "родных" методов;
библиотеку классов Java API (Application Programming Interface).
В прежние версии JDK включались и отладочные варианты исполнимых программ: javac_g, java_g И Т. Д.
Компания SUN Microsystems постоянно развивает и обновляет JDK, каждый год появляются новые версии.
В 1996 г. была выпущена первая версия JDK 1.0, которая модифицировалась до версии с номером 1.0.2. В этой версии библиотека классов Java API содержала 8 пакетов. Весь набор JDK 1.0.2 поставлялся в упакованном виде в одном файле размером около 5 Мбайт, а после распаковки занимал около 8 Мбайт на диске.
В 1997 г. появилась версия JDK 1.1, последняя ее модификация, 1.1.8, выпущена в 1998 г. В этой версии было 23 пакета классов, занимала она 8,5 Мбайт в упакованном виде и около 30 Мбайт на диске.
В первых версиях JDK все пакеты библиотеки Java API были упакованы в один архивный файл classes.zip и вызывались непосредственно из этого архива, его не нужно распаковывать.
Затем набор инструментальных средств JDK был сильно переработан.
Версия JDK 1.2 вышла в декабре 1998 г. и содержала уже 57 пакетов классов. В архивном виде это файл размером почти 20 Мбайт и еще отдельный файл размером более 17 Мбайт с упакованной документацией. Полная версия располагается на 130 Мбайтах дискового пространства, из них около 80 Мбайт занимает документация.

Начиная с этой версии, все продукты технологии Java собственного производства компания SUN стала называть

Java 2 Platform, Standard Edition,

сокращенно J2SE, a JDK переименовала в

Java 2 SDK, Standard Edition

(Software Development Kit), сокращенно J2SDK, поскольку выпускается еще

Java 2 SDK Enterprise Edition

и

Java 2 SDK Micro Edition.

Впрочем, сама компания SUN часто пользуется и старым названием, а в литературе утвердилось название Java 2. Кроме 57 пакетов классов, обязательных на любой платформе и получивших название

Core API,

в Java 2 SDK vl.2 входят еще дополнительные пакеты классов, называемые Standard Extension API. В версии Java 2 SDK SE, vl.3, вышедшей в 2000 г., уже 76 пакетов классов, составляющих Core API. В упакованном виде это файл размером около 30 Мбайт, и еще файл с упакованной документацией размером 23 Мбайта. Все это распаковывается в 210 Мбайт дискового пространства. Эта версия требует процессор Pentium 166 и выше и не менее 32 Мбайт оперативной памяти.

В настоящее время версия JDK 1.0.2 уже не используется. Версия JDK 1.1.5 с графической библиотекой AWT встроена в популярные браузеры Internet Explorer 5.0 и Netscape Communicator 4.7, поэтому она применяется для создания апплетов. Технология Java 2 широко используется на серверах и в клиент-серверных системах.

Кроме JDK, компания SUN отдельно распространяет еще и набор JRE (Java Runtime Environment).

Что такое JRE

Набор программ и пакетов классов JRE содержит все необходимое для выполнения байт-кодов, в том числе интерпретатор java (в прежних версиях облегченнный интерпретатор jre) и библиотеку классов. Это часть JDK, не содержащая компиляторы, отладчики и другие средства разработки. Именно JRE или его аналог других фирм содержится в браузерах, умеющих выполнять программы на Java, операционных системах и системах управления базами данных.
Хотя JRE входит в состав JDK, фирма SUN распространяет этот набор и отдельным файлом.
Версия JRE 1.3.0 — это архивный файл размером около 8 Мбайт, разворачивающийся в 20 Мбайт на диске.

Файл INDEX.LIST

Для ускорения поиска файлов и более быстрой их загрузки можно создать файл поиска INDEX.LIST. Это делается после создания архива. Утилита jar запускается еще раз с параметром
-i,
например:
jar -i Base.jar
После этого в каталоге META-INF архива появляется файл INDEX.LIST. На рис. П.З представлено, как создается файл поиска и как выглядит содержимое архива после его создания.

Рис. П.3.
Создание файла поиска

Файл описания MANIFEST.MF

Файл MANIFEST.MF, расположенный в каталоге META-INF архивного файла, предназначен для нескольких целей:
перечисления файлов из архива, снабженных цифровой подписью;
перечисления компонентов JavaBeans, расположенных в архиве;
указания имени основного класса для выполнения-приложения из архива;
записи сведений о версии пакета.
Вся информация сначала записывается в обычном текстовом файле с любым именем, например, manif. Потом запускается утилита jar, в которой этот файл указывается как значение параметра т, например:
jar cmf manif Base.jar classes Base.class
Утилита проверяет правильность записей в файле manif и переносит их в файл MANIFEST.MF, добавляя свои записи.
Файл описания manif должен быть написан по строгим правилам, изложенным в спецификации JAR File Specification. Ее можно найти в документации Java 2 SDK, в файле docs\guide\jar\jar.html.
Например, если мы хотим выполнять приложение с главным файлом Base.class из архива Base.jar, то файл manif должен содержать как минимум две строки:
Main-Class: Base
Первая строка содержит относительный путь к главному классу, но не к файлу, т. е. без расширения class. В этой строке каждый символ имеет значение, даже пробел. Вторая строка пустая — файл обязательно должен заканчиваться пустой строкой, точнее говоря, символом перевода строки '\n'.
После того как создан архив Base.jar, можно выполнять приложение прямо из него:
Java -jar Base.jar



Что такое Java

Структура книги

Выполнение Java-программы

Что такое JDK

Что такое JRE

Как установить JDK

Как использовать JDK

Интегрированные среды Java

Особая позиция Microsoft

Java в Internet

Литература no Java

Интегрированные среды Java

Сразу же после создания Java, уже в 1996 г., появились интегрированные среды разработки программ для Java, и их число все время возрастает. Некоторые из них являются просто интегрированными оболочками над JDK, вызывающими из одного окна текстовый редактор, компилятор и интерпретатор. Эти интегрированные среды требуют предварительной установки JDK. Другие содержат JDK в себе или имеют собственный компилятор, например, Java Workshop фирмы SUN Microsystems, JBuilder фирмы Inprise, Visual Age for Java фирмы IBM и множество других программных продуктов. Их можно устанавливать, не имея под руками JDK. Надо заметить, что перечисленные продукты написаны полностью на Java.
Большинство интегрированных сред являются средствами визуального программирования и позволяют быстро создавать пользовательский интерфейс, т е. относятся к классу средств RAD (Rapid Application Development).
Выбор какого-либо средства разработки диктуется, во-первых, возможностями вашего компьютера, ведь визуальные среды требуют больших ресурсов, во-вторых, личным вкусом, в-третьих, уже после некоторой практики, достоинствами компилятора, встроенного в программный продукт.
В России по традиции, идущей от TurboPascal к Delphi, большой популярностью пользуется JBuilder, позволяющий подключать сразу несколько JDK разных версий и использовать их компиляторы кроме собственного. Многие профессионалы предпочитают Visual Age for Java, в котором можно графически установить связи между объектами.
К технологии Java подключились и разработчики CASE-средств. Например, популярный во всем мире продукт Rational Rose может сгенерировать код на Java.

Java на сервере

Тенденция написания сетевых программ — побольше функций возложить на серверную часть программы и поменьше оставить клиентской части, сделав клиент "тонким", а сервер "толстым". Это позволяет, с одной стороны, использовать клиентскую часть программы на самых старых и маломощных компьютерах, а с другой стороны, облегчает модификацию программы — все изменения достаточно сделать только в одном месте, на сервере.
Сервер выполняет все больше функций, как говорят,
служб
или
сервисов
(services). Он и отправляет клиенту Web-страницы, и выполняет сервлеты, и связывается с базой данных, и обеспечивает транзакции. Такой многофункциональный сервер называется
сервером приложений
(application server). Большой популярностью сейчас пользуются серверы приложений WebLogic фирмы ВЕА Systems, IAS (Inprise Application Server) фирмы Borland, WebSphere фирмы IBM, OAS (Oracle Application Server). Важной характеристикой сервера приложений является способность расширять свои возможности путем включения новых модулей. Это удобно делать с помощью компонентов.
Фирма SUN Microsystems предложила свою систему компонентов EJB (Enterprise JavaBeans), включенную в Java 2 SDK Enterprise Edition. Подобно тому, как графические компоненты JavaBeans реализуют графический интерфейс пользователя, размещаясь в графических контейнерах, компоненты EJB реализуют различные службы на сервере, располагаясь в EJB-контейнерах. Этими контейнерами управляет EJB-сервер, включаемый в состав сервера приложений. В составе J2SDKEE EJB-сервер — это программа j2ee. Серверу приложений достаточно запустить эту программу, чтобы использовать компоненты EJB.
В отличие от JavaBeans у компонентов EJB не может быть графического интерфейса и ввода с клавиатуры. У них может отсутствовать даже консольный вывод. Контейнер EJB занимается не размещением компонентов, а созданием и удалением их объектов, связью с клиентами и другими компонентами, проверкой прав доступа и обеспечением транзакций.
Программы, оформляемые как EJB, могут быть двух типов: EntityBean и sessionBean. Они реализуют соответствующие интерфейсы из пакета javax.ejb. Первый тип EJB-компонентов удобен для создания программ, обращающихся к базам данных и выполняющих сложную обработку полученной информации. Компоненты этого типа могут работать сразу с несколькими клиентами. Второй тип EJB-компонентов более удобен для организации взаимодействия с клиентом. Компоненты этого типа бывают двух видов: сохраняющие свое состояние от запроса к запросу (stateful) и теряющие это состояние (stateless). Методами интерфейсов EntityBean и SessionBean контейнер EJB управляет поведением экземпляров класса. Если достаточно стандартного управления, то можно сделать пустую реализацию этих методов.

Кроме класса, реализующего интерфейс EntityBean или SessionBean, для создания компонента EJB необходимо создать еще два интерфейса, расширяющие интерфейсы вовноте и EjBObject. Первый интерфейс (home interface) служит для создания объекта EJB своими методами create (), для поиска и связи с этим объектом в процессе работы, и удаления его методом remove о. Второй интерфейс (remote interface) описывает методы компонента EJB. Интересная особенность технологии EJB — клиентская программа не образует объекты компонента EJB. Вместо этого она создает объекты home-и remote-интерфейсов и работает с этими объектами. Реализация home- и remote-интерфейсов, создание объектов компонента EJB и взаимодействие с ними остается на долю контейнера EJB.

Приведем простейший пример. Пусть мы решили обработать выборку из базы данных, занесенную в объект rs в сервлете листинга П.З, с помощью компонента EJB. Для простоты пусть обработка заключается в слиянии двух столбцов методом merge (). Напишем программу:

import java.rmi.RemoteException;

import javax.ejb.*;

public class MergeBean implements SessionBean{

public String merge(String si, String s2){

String s = si + " " + s2;

return s;

}

// Выполняется при обращении к методу create()

// интерфейса MergeHome. Играет роль конструктора класса

public void ejbCreate() {}

// Пустая реализация методов интерфейса

public void setSessionContext(SessionContext ctx){}

public void ejbRemoveO {}

public void ejbActivate()(}

public void ejbPassivate(){} }

public interface MergeHome extends EJBHome{

// Реализуется методом ejbCreate() класса MergeBean

Merge create)} throws CreateException, RemoteException;

}

public interface Merge extends EJBObject{

public double merge(String si, String s2)

throws RemoteException;

}

В сервлете листинга П.3 создаем объекты типа MergeHome и Merge и обращаемся к их методам:


import j avax.servlet.*;

import j avax.servlet.http.*;

import java.io.*;

import j avax.naming.*;

import j avax.rmi.PortableRemoteObj ect;

public class JDBCServlet extends HttpServlet {

MergeHome mh;

Merge m;

// Следующие определения

//.......

public void init(ServletConfig conf) throws ServletExceptionf

try( // Поиск объекта merge, реализующего MergeHome

InitialContext ic = new InitialContext(};

Object ref = ic.lookup("merge");

mh = (MergeHome)PortableRemoteObject.narrow(

ref, MergeHome.class); }catch(Exception e){

e.printStackTrace(); }

public void doPost(HttpServletRequest req, HttpServletResponse resp)

throws IOException, ServletExceptionf

// Начало метода

//........

m = mh.create();

String s = m.merge(si, s2);

// и т. д.

}

}

После компиляции получаем EJB-приложение, состоящее из пяти файлов: JdbcServlet.html, JdbcServlet.class, MergeBean.class, MergeHome.class и Merge.class. Осталось правильно установить (deploy) его в контейнер EJB. Файлы jdbcserviet.html и JdbcServlet.class надо упаковать в один war-файл, остальные файлы — в один jar-файл, потом оба получившихся файла упаковать в один ear-файл (Enterprise ARchive). Кроме того, надо создать еще файл описания установки (deployment descriptor) в формате XML и занести его в архив. В этот файл, в частности, записывается имя "merge", по которому компонент отыскивается методом lookup ().

Все это можно сделать утилитой depioytool, входящей в состав Java 2 SDK Enterprise Edition. Эта же утилита позволяет проверить работу приложения и установить его в контейнер EJB. Надо только предварительно запустить EJB-сервер командой j2ee.

Впрочем, все файлы EJB-приложения можно упаковать в один jar-файл.

Многие серверы приложений и средства разработки, такие как Borland JBuilder и IBM Visual Age for Java, имеют в своем составе утилиты для установки EJB-приложений.

EJB-приложение готово. Теперь достаточно вызвать в браузере HTML-файл и заполнить появившуюся в окне форму.

Java в Internet

Разработанная для применения в сетях, Java просто не могла не найти отражения на сайтах Internet. Действительно, масса сайтов полностью посвящена или содержит информацию о технологии Java. Одна только фирма SUN содержит несколько сайтов с информацией о Java:


http://www.sun.com/

— здесь все ссылки, отсюда можно скопировать JDK;


http://java.sun.com/

— основной сайт Java, отсюда тоже можно скопировать JDK;


http://developer.java.sun.com/

— масса полезных вещей для разработчика;


http://industry.java.sun.com/

— новости технологии Java;


http://www.javasoft.com/

— сайт фирмы JavaSoft, подразделения SUN;


http://www.gamelan.com/


.
На сайте фирмы IBM есть большой раздел

http://www.ibm.com/developer

. /Java/, где можно найти очень много полезного для программиста.
Компания Microsoft содержит информацию о Java на своем сайте:

http://


www.microsoft.com/java/.
Большой вклад в развитие технологии Java вносит корпорация Oracle:

http://www.oracle.coin/


.
Существует множество специализированных сайтов:


http://java.iba.com.by/

— Java team IBA (Белоруссия);


http://www.artima.com/;



http://www.freewarejava.com/;



http://www.jars.com/

— Java Review Service;

http://www.javable.com
— русскоязычный сайт;


http://www.javaboutique.com/;



http://www.javalobby.com/;



http://www.javalogy.com/;



http://www.javaranch.com/;



http://www.javareport.com/

— независимый источник информации для разработчиков;


http://www.javaworld.com

— электронный журнал;


http://www.jfind.com/

— сборник программ и статей;


http://www.jguru.com/

— советы специалистов;


http://www.novocode.com/;



http://www.sigs.com/jro/

— Java Report Online;


http://www.sys-con.com/java/;



http://theserverside.com/

— вопросы создания серверных Java-приложений;


http://servlets.chat.ru/;



http://javapower.da.ru/

— собрание FAQ на русском языке;


http://www.purejava.ru/;



http://java7.da.ru/;







http://codeguru.earthweb.com/java/



— большой сборник апплетов и других программ;





http://securingjava.com/



— обсуждаются вопросы безопасности;





http://www.servlets.com/



— вопросы по написанию апплетов;





http://www.servletsource.com/;







http://coolservlets.com/;







http://www.servletforum.com/;







http://www.javacats.com/

.



Персональные сайты:





http://www.bruceeckel.com/



— сайт Bruce Eckel;





http://www.davidreilly.com/java/;





http://www.comita.spb.ru/users/sergeya/java/

— хозяин, Сергей Астахов, собрал здесь буквально все, касающееся русификации Java.

К сожалению, адреса сайтов часто меняются. Возможно, вы и не найдете некоторые из перечисленных сайтов, зато возникнет много других.

Как использовать JDK

Несмотря на то, что набор JDK предназначен для создания программ, работающих в графических средах, таких как MS Windows или X Window System, он ориентирован на выполнение из командной строки окна

MS-DOS Prompt
в Windows 95/98/ME или окна
Command Prompt
в Windows NT/2000. В системах UNIX можно работать и в текстовом режиме и в окне
Xterm.
Написать программу на Java можно в любом текстовом редакторе, например, Notepad, WordPad в MS Windows, редакторах vi, emacs в UNIX. Надо только сохранить файл в текстовом формате и дать ему расширение Java.
Пусть для примера, именем файла будет MyProgram.java, а сам файл сохранен в текущем каталоге.
После создания этого файла из командной строки вызывается компилятор javac и ему передается исходный файл как параметр:
javac MyProgram.java
Компилятор создает в том же каталоге по одному файлу на каждый класс, описанный в программе, называя каждый файл именем класса с расширением class. Допустим, в нашем примеру имеется только один класс, названный MyFrogram, тогда получаем файл с именем MyProgram.class, содержащий байт-коды.
Компилятор молчалив — если компиляция прошла успешно, он ничего не сообщит, на экране появится только приглашение операционной системы. Если же компилятор заметит ошибки, то он выведет, на экран сообщения о них. Большое достоинство компилятора JDK в том> чтЪ он "отлавливает" много ошибок и выдает подробные и понятные сообщения о них.
Далее из командной строки вызывается интерпретатор байт-кодов jaya, которому передается файл с байт-кодами, причем его имя записывается без расширения (смысл этого вы узнаете позднее):
Java MyProgram
На экране появляется вывод результатов работы программы или сообщения об ошибках времени выполнения.
Если работа из командной строки, столь милая сердцу "юниксоидов", кажется вам несколько устаревшей, используйте для разработки интегрированную среду.

Как установить JDK

Набор JDK упаковывается в самораспаковывающийся архив. Раздобыв каким-либо образом этот архив: "выкачав" из Internet, с

http://java.sun.com /produets/jdk/



или какого-то другого адреса, получив компакт-диск, вам остается только запустить файл с архивом на выполнение. Откроется окно установки, в котором среди всего прочего вам будет предложено выбрать каталог (directory) установки, например, C:\jdkl.3. Если вы согласитесь с предлагаемым каталогом, то вам больше не о чем беспокоиться. Если вы указали собственный каталог, то проверьте после установки значение переменной PATH, набрав в командной строке окна
MS-DOS Prompt (или
окна
Command Prompt
в Windows NT/2000, а тот, кто работает в UNIX, сами знают, что делать) команду set. Переменная PATH должна содержать полный путь к подкаталогу bin этого каталога. Если нет, то добавьте этот путь, например, C:\jdkl.3\bin. Надо определить и специальную переменную CLASSPATH, содержащую пути к архивным файлам и каталогам с библиотеками классов. Системные библиотеки Java 2 подключаются автоматически, без переменной CLASSPATH.
Еще одно предупреждение: не следует распаковывать zip- и jar-архивы.
После установки вы получите каталог с названием, например, jdkl.3, а в нем подкаталоги:
bin, содержащий исполнимые файлы;
demo, содержащий примеры программ;
docs, содержащий документацию, если вы ее установили;
include, содержащий заголовочные файлы "родных" методов;
jre, содержащий набор JRE;
old-include, для совместимости со старыми версиями;
lib, содержащий библиотеки классов и файлы свойств;
src, с исходными текстами программ JDK. В новых версиях вместо каталога имеется упакованный файл src.jar.
Да-да! Набор JDK содержит исходные тексты большинства своих программ, написанные на Java. Это очень удобно. Вы всегда можете в точности узнать, как работает тот или иной метод обработки информации из JDK, посмотрев исходный код данного метода. Это очень полезно и для изучения Java на "живых" работающих примерах.

Компоненты JavaBeans

Многие программисты предпочитают разрабатывать приложения с графическим интерфейсом пользователя с помощью визуальных средств разработки: JBuilder, Visual Age for Java, Visual Cafe и др. Эти средства позволяют помещать компоненты в контейнер графически, с помощью мыши. На рис. П.4 показано окно JBuilder 4.
Левый нижний угол окна занимает форма, на которой размещаются компоненты. Сами компоненты показаны ярлыками на панели компонентов, расположенной выше формы. На рис. П.4 на панели компонентов виден ярлык компонента Button, показанный прямоугольником с надписью ОК, ярлык компонента checkbox, показанный квадратиком с крестиком, ярлык компонента checkboxGroup, обозначенный группой радиокнопок. Далее видны ярлыки компонентов choice, Label, List и другие компоненты AWT.
Чтобы поместить компонент в форму, надо щелкнуть кнопкой мыши на ярлыке компонента, перенести курсор мыши в нужное место формы и щелкнуть кнопкой мыши еще раз.
Затем с помощью мыши необходимо установить нужные размеры компонента. При этом можно передвинуть компонент на другое место. На рис. П.4 в форму помещена кнопка типа Button.

Рис. П.4.
Окно JBuilder 4
Далее следует определить свойства (properties) компонента: текст, цвет текста и фона, вид курсора мыши, когда он появляется над компонентом Свойства определяются в окне свойств, расположенном справа от формы В левой колонке окна перечислены имена свойств, в правую колонку надо записать их значения. На рис. П.4 свойству label — надписи на кнопке — дано значение Выполнить. Это значение тут же появляется на кнопке
Потом можно задать обработку событий, открыв вторую страницу окна свойств.
Для того чтобы компонент можно было применять в таком визуальном средстве разработки как JBuilder, он должен обладать дополнительными качествами. У него должен быть ярлык, помещаемый на панель компонентов. Среди полей компонента должны быть выделены свойства (properties), которые будут показаны в окне свойств Следует определить методы доступа
getXxx () /setXxx () /isXxx ()

к каждому свойству

Компонент, снабженный этими и другими необходимыми качествами, в технологии Java называется компонентом JavaBean. В него может входить один или несколько классов. Как правило, файлы этих классов упаковываются в jar-архив и отмечаются в файле MANIFEST.MF как Java-Bean: True.

Все компоненты AWT и Swing являются компонентами JavaBeans. Если вы создаете свой графический компонент по правилам, изложенным в

части 3,

то вы тоже получаете свой JavaBean. Но для того чтобы не упустить каких-либо важных качеств JavaBean, лучше использовать для их разработки специальные средства.

Фирма SUN поставляет набор необходимых утилит и классов BDK (Beans Development Kit) для разработки JavaBeans. Так же, как и SDK, этот набор хранится на сайте фирмы в виде самораспаковывающегося архива, например, bdkl_l-win.exe. Его содержимое распаковывается в один каталог, например, D:\bdkl.l. После перехода в каталог bdkl.l\beanbox\ и запуска файла run.bat (или run.sh в UNIX) открываются несколько окон утилиты Bean-Box, работа с которой ведется по тому же принципу, что и в визуальных средствах разработки.

Правила оформления компонентов JavaBeans изложены в спецификации JavaBeans API Specification, которую можно найти по адресу http://

java.sun.com/products/javabeans/docs/spec.html.

Визуальные средства разработки — это не основное применение JavaBeans. Главное достоинство компонентов, оформленных как JavaBeans, в том, что они без труда встраиваются в любое приложение. Более того, приложение можно собрать из готовых JavaBeans как из строительных блоков, остается только настроить их свойства.

Специалисты пророчат большое будущее компонентному программированию. Они считают, что скоро будут созданы тысячи компонентов JavaBeans на все случаи жизни и программирование сведется к поиску в Internet нужных компонентов и сборке из них приложения.

Литература по Java

Перечислим здесь только основные, официальные и почти официальные издания, более полное описание чрезвычайно многочисленной литературы дано в списке литературы в конце книги.
Полное и строгое описание языка изложено в книге
The Java Language Specification, Second Edition. James Gosling, Bill Joy, Guy Steele, Gilad Bracha.
Эта книга в электронном виде находится по адресу

http://java.sun.com/docs


/books/jls/second_edition/html/j.title.doc.html
и занимает в упакованном виде около 400 Кбайт.
Столь же полное и строгое описание виртуальной машины Java изложено в книге
The Java Virtual Machine Specification, Second Edition. Tim Lindholm, Frank Yellin.
В электронном виде она находится по адресу

http://java.sun.com


/docs/books/vmspec/2nd-edition/html/VMSpecTOC.doc.htmI.
Здесь же необходимо отметить книгу "отца" технологии Java Джеймса Гос-линга, написанную вместе с Кеном Арнольдом. Имеется русский перевод Гослинг Дж., Арнольд К. Язык программирования Java: Пер. с англ. — СПб.: Питер, 1997. — 304 с.: ил.
Компания SUN Microsystems содержит на своем сайте постоянно обновляемый электронный учебник Java Tutorial, размером уже более 14 Мбайт:

http://java.sun.com/docs/books/tutorial/


.

Время от времени появляется его печатное издание
The Java Tutorial, Second Edition: Object-Oriented Programming for the Internet. Mary Campione, Kathy Walrath.
Полное описание Java API содержится в документации, но есть печатное издание
The Java Application Programming Interface. James Gosling, Frank Yellin and the Java Team, Volume 1: Core Packages; Volume 2: Window Toolkit and Applets.

Особая позиция Microsoft

Вы уже, наверное, почувствовали смутное беспокойство, не встречая название этой фирмы. Дело в том, что, имея свою операционную систему, огромное число приложений к ней и богатейшую библиотеку классов, компания Microsoft не имела нужды в Java. Но и пройти мимо технологии, распространившейся всюду, компания Microsoft не могла и создала свой компилятор Java, а также визуальное средство разработки, включив его в Visual Studio. Этот компилятор включает в байт-коды вызовы объектов ActiveX. Следовательно, выполнять эти байт-коды можно только на компьютерах, имеющих доступ к ActiveX. Эта "нечистая" Java резко ограничивает круг применения байт-кодов, созданных компилятором фирмы Microsoft. В результате судебных разбирательств с SUN Microsystems компания Microsoft назвала свой продукт Visual J++. Виртуальная машина Java фирмы Microsoft умеет выполнять байт-коды, созданные "чистым" компилятором, но не всякий интерпретатор выполнит байт-коды, написанные с помощью Visual J++.
Чтобы прекратить появление несовместимых версий Java, фирма SUN разработала концепцию "чистой" Java, назвав ее
Pure Java,
и систему проверочных тестов на "чистоту" байт-кодов. Появились байт-коды, успешно прошедшие тесты, и средства разработки, выдающие "чистый" код и помеченные как
"100% Pure Java".
Кроме того, фирма SUN распространяет пакет программ Java Plug-in, который можно подключить к браузеру, заменив тем самым встроенный в браузер JRE на "родной".

Переход к Swing

В
части 3
мы подробно рассмотрели возможности графической библиотеки AWT. Там же мы заметили, что в состав Java 2 SDK входит еще одна графическая библиотека, Swing, с более широкими возможностями, чем AWT. Фирма SUN настоятельно рекомендует использовать Swing, а не AWT, но, во-первых, Swing требует больше ресурсов, что существенно для российского разработчика, во-вторых, большинство браузеров не имеет в своем составе Swing. В-третьих, удобнее сначала познакомиться с библиотекой AWT, а уже потом изучать Swing.
Все примеры графических программ, приведенные в книге, будут выполняться методами библиотеки Swing после небольшой переделки:
1. Добавьте в заголовок строку import javax.swing.*;.
2. Поменяйте Frame на JFrame, Applet на JApplet, Component нa JComponent, Panel на JPanei. He расширяйте свои классы от класса canvas, используйте jpanei или другие контейнеры Swing.
3. Замените компоненты AWT на близкие к ним компоненты Swing. Чаще всего надо просто приписать букву j: JButton, JcheckBox, JDialog, jList, JMenu и т. д. Закомментируйте временно строку import java.awt.*; и попробуйте откомпилировать программу. Компилятор покажет, какие компоненты требуют замены.
4. Включите в конструктор класса, расширяющего JFrame, строку Container с = getContentPane (); и располагайте все компоненты в контейнере с, Т. е. пишите c.add(), с.setLayout ().
5. Класс jFrame содержит средства закрытия своего окна, надо только настроить их. Вы можете убрать addwindowListener(...) и включить в конструктор обращение К методу setDefaultCloseQperation(JFrame.EXITJB_CLOSE).
6. В прямых подклассах класса jpanei замените метод paint о на paintcomponent () и удалите метод update о. Класс jpanei автоматически производит двойную буферизацию и надобности в методе update о больше нет. Уберите весь код двойной буферизации. В начало метода paintcomponent () включите обращение super.paintcomponent (g). Из подклассов классов JFrame, joialog, JAppiet метод paintcomponent () надо переместить в другие компоненты, например, JButton, JLabel, jpanei.

7. Используйте вместо класса image класс imageicon. Конструкторы этого класса выполнят необходимое преобразование. Класс imageicon автоматически применяет методы класса MediaTracker для ожидания окончания загрузки.

8. При создании апплетов расширением класса JAppiet не забывайте, что в классе Applet менеджером размещения по умолчанию служит класс FiowLayout, а в классе JAppiet менеджер размещения по умолчанию

BorderLayout.

Пункты 4 и 6 требуют пояснения. Окно верхнего уровня в Swing, такое как JFrame, содержит

корневую панель

(root pane), на которой размещена

слоеная панель

(layered pane). Компоненты на слоеной панели можно размещать несколькими слоями, перекрывая друг друга. В одном из слоев находится

панель содержимого

(content pane) и

строка меню

(menu bar). Поверх самого верхнего слоя расположена

прозрачная панель

(glass pane). Поэтому нельзя просто поместить компонент в окно верхнего уровня. Его надо "положить" на какую-нибудь панель. Пункт 4 рекомендует размещать компоненты на панели содержимого.

Откомпилировав и запустив измененную программу, вы увидите, что ее внешний вид изменился, чаще всего не в лучшую сторону. Теперь надо настроить компоненты Swing. Библиотека Swing предоставляет для этого широчайшие возможности.

Сервлеты

В
главе 19
была упомянута технология CGI. Ее суть в том, что сетевой клиент, обычно браузер, посылает Web-серверу информацию вместе с указанием программы, которая будет обрабатывать эту информацию. Web-сервер, получив информацию, запускает программу, передает информацию на ее стандартный ввод и ждет окончания обработки. Результаты обработки программа отправляет на свой стандартный вывод, Web-сервер забирает их оттуда и отправляет клиенту. Написать программу можно на любом языке, лишь бы Web-сервер мог взаимодействовать с ней.
В технологии Java такие программы оформляются как
сервлеты
(servlets). Это название не случайно похоже на название "апплеты". Сервлет на Web-сервере играет такую же роль, что и апплет в браузере, расширяя его возможности.
Чтобы Web-сервер мог выполнять сервлеты, в его состав должна входить JVM и средства связи с сервлетами. Обычно все это поставляется в виде отдельного модуля, встраиваемого в Web-сервер. Существует много таких модулей: Resin, Tomcat, JRun, JServ. Они называются на жаргоне
сервлетными движками
(servlet engine).
Основные интерфейсы и классы, описывающие сервлеты, собраны в пакет javax.servlet. Расширения этих интерфейсов и классов, использующие конкретные особенности протокола HTTP, собраны в пакет javax.servlet.http. Еще два пакета— javax.servlet.jsp и javax.servlet.jsp.tagext — предназначены для связи сервлетов со скриптовым языком JSP (JavaServer Pages). Все эти пакеты входят в состав J2SDK Enterprise Edition. Они могут поставляться и отдельно как набор JSDK (Java Servlet Development Kit). Сервлет-ный движок должен реализовать эти интерфейсы.
Основу пакета javax.servlet составляет интерфейс servlet, частично реализованный в абстрактном классе GenericServiet и его абстрактном подклассе HttpServiet. Основу этого интерфейса составляют три метода:
init (Servietconfig config)
— задает начальные значения сервлету, играет ту же роль, что и метод init () в апплетах;
service(ServletRequest req, ServletResponse resp)

— выполняет обработку поступившей сервлету информации req и формирует ответ resp;

destroy ()

— завершает работу сервлета.

Опытный читатель уже понял, что вся работа сервлета сосредоточена в методе service о. Действительно, это единственный метод, не реализованный в классе GenericServiet. Достаточно расширить свой класс от класса . GenericServiet и реализовать в нем метод service (), чтобы получить собственный сервлет. Сервлетный движок, встроенный в Web-сервер, реализует интерфейсы ServletRequest и ServletResponse. Он Создает объекты req и resp, заносит всю поступившую информацию в объект req и передает этот объект сервлету вместе с пустым объектом resp. Сервлет принимает эти объекты как аргументы req и resp метода service о, обрабатывает информацию, заключенную в req, и оформляет ответ, заполняя объект resp. Движок забирает этот ответ и через Web-сервер отправляет его клиенту.

Основная информация, заключенная в объекте req, может быть получена методами read() и readLine() ИЗ байтового потока класса ServletlnputStream, непосредственно расширяющего класс inputstream, или из символьного потока класса BufferedReader. Эти потоки открываются, соответственно, методом req.getlnputStream() или методом req.getReader (). Дополнительные характеристики запроса можно получить многочисленными методами getxxxo объекта req. Кроме того, класс GenericServlet реализует массу методов getxxxo, позволяющих получить дополнительную информацию о конфигурации клиента.

Интерфейс servietResponse описывает симметричные методы для формирования ответа. Метод getoutputstreamo открывает байтовый поток класса ServletOutputStream, непосредственно расширяющего класс OutputStream. МеТОД getWriter () открывает символьный поток класса PrintWriter.

Итак, реализуя метод service!), надо получить информацию из входного потока объекта req, обработать ее и результат записать в выходной поток объекта resp.

Очень часто в объекте req содержится запрос к базе данных. В таком случае метод service о обращается через JDBC к базе данных и формирует ответ resp из полученного объекта ResultSet.


Протокол HTTP предлагает несколько методов передачи данных: GET, POST, PUT, DELETE. Для их использования класс GenericServlet расширен классом HttpServlet, находящимся В пакете javax.servlet.http. В этом классе есть методы для реализации каждого метода передачи данных:

doGet(HttpServletRequest req, HttpServletResponse resp)

doPost(HttpServletRequest req, HttpServletResponse resp)

doPut(HttpServletRequest req, HttpServletResponse resp)

doDelete(HttpServletRequest req, HttpServletResponse resp)

Для работы с конкретным HTTP-методом передачи данных достаточно расширить свой класс от класса HttpServlet и реализовать один из этих методов. Метод service () переопределять не надо, в классе HttpServlet он только определяет, каким HTTP-методом передан запрос клиента, и обращается к соответствующему методу doXxxo. Аргументы перечисленных методов req и resp — это объекты, реализующие Интерфейсы HttpServletRequest и HttpServletResponse, расширяющие интерфейсы ServletRequest и ServietResponse, соответственно.

Интерфейс HttpServletRequest к тому же описывает множество методов getxxx (), позволяющих получить дополнительные свойства запроса req.

Интерфейс HttpServletResponse описывает методы addxxxO и setxxxo, дополняющие ответ resp, и статические константы с кодами ответа Web-сервера.

В листингах П.2 и П.З те же действия, что выполняет программа листинга П. 1, реализованы с помощью сервлета. Апплет теперь не нужен, в окно браузера выводится HTML-форма, описанная в листинге П.2.



Листинг П.2.

HTML-форма запроса к базе данных

URL базы: 

value = "jdbc:oracle:thin:@localhost:1521:ORCL"> 


Имя: 



value = "scott"> 


Пароль: 

value = "tiger"> 


Запрос: 


<br><br>
SELECT * FROM dept <br><br>



 

Сервлет получает из этой формы адрес базы url, имя login и пароль password пользователя, а также запрос query. Он обращается к базе данных Oracle через драйвер JDBC Oracle Thin, формирует полученный ответ в виде HTML-страницы и отправляет браузеру.



Листинг П.3

. Сервлет, выполняющий запрос к базе Oracle i

import java.io.*;

import javax.servlet.*;

import javax.servlet.http.*;

import java.util.*;

import j ava.sql.*;

public class JdbcServlet extends HttpServlet{ static)

try{

DriverManager.registerDriver(

new oracle.j dbc.driver.OracleDriver());

)catch(SQLException e){

System.err.println(e) ;

}

)

private Vector results = new Vector();

private int n;

public void doPost(HttpServletRequest req, HttpServletResponse resp)

throws IOException{

ServletExceptionf String url = req.getParameter("url") ,

login = req.getParameter("login") ,

password = req.getParameter("password") ,

query = req.getParameter("query");

// Задаем MIME-тип и кодировку для выходного потока pw

resp.setContentType("text/html;charset=windows-1251");

PrintWriter pw = resp.getWriter();

try{

Connection con =

DriverManager.getConnection(url, login, password);

Statement st = con.createStatement();

ResultSet rs = st.executeQuery(query);

ResultSetMetaData rsmd = rs.getMetaData();


n = rsmd.getColumnCount(); while (rs.next()){

String s = " ";

for (int i = 1; i <= n; i++)

s += " " + rs.getObject(i);

results.addElement(s); }

rs.close();

st.close();

con.close();

}catch(SQLException e){

pw.println("From doPostf): " + e) ;

}

pw.println("

Ниже выполняется апплет.








В апплете для приема каждого параметра надо воспользоваться методом getParameter (String name) класса Applet, Возвращающим строку типа String. В качестве аргумента этого метода задается значение параметра name в виде строки, причем здесь не различается регистр букв, а метод возвращает, значение параметра value тоже в виде строки.


Замечание по отладке

Операторы System.out.println(), обычно записываемые в апплет для отладки, выводят указанные в них аргументы в специальное окно браузера Java Console. Сначала надо установить возможность показа этого окна. В Internet Explorer это делается установкой флажка Java Console enabled выбором команды Tools | Internet Options | Advanced. После перезапуска IE в меню View появляется команда Java Console.
В листинге 14.8 показан переработанный апплет HelloWorld. В нем назначен белый фон, а шрифт устанавливается с параметрами, извлеченными из HTML-файла.

Листинг 14.8.

Апплет, принимающий параметры
import j ava.awt.*;
import j ava.applet.*;
public class HelloWorld extends Applet{ public void init(){

setBackground(Color.white);

String font = "Serif";

int style = Font.PLAIN, size = 10;

font = getParameter("fontName");

style = Integer.parselnt(getParameter("fontStyle"));

size = Integer.parselnt(getParameter("fontsize"));

setFont(new Font(font, style, size));

}

public void paint(Graphics g){

g.drawstring("Hello, XXI century World!", 10, 30);

}

}





Совет



Надеясь на то, что параметры будут заданы в HTML-файле, все-таки присвойте начальные значения переменным в апплете, как это сделано в листинге 14.8.

На рис. 14.4 показан работающий апплет.

Рис. 14.4.

Апплет с измененным шрифтом

Правила хорошего тона рекомендуют описать параметры, передаваемые ап-плету, в виде массива, каждый элемент которого — массив из трех строк, соответствующий одному параметру. Данная структура представляется в виде "имя", "тип", "описание". Для нашего примера можно написать:

String!][] pinfo = {

{"fontName", "String", "font name"},

{"fontStyle", "int", "font style"},

{"fontsize", "int", "font size"}

};

Затем переопределяется метод getParameterinfoO, возвращающий указанный массив. Это пустой метод класса Applet. Любой объект, желающий узнать, что передать апплету, может вызвать этот метод. Для нашего примера переопределение выглядит так:

public String[][] getParameterlnfо(){

return pinfo;

}

Кроме того, правила хорошего тона предписывают переопределить метод getAppletinfо (), возвращающий строку, в которой записано имя автора, версия апплета и прочие сведения об апплете, которые вы хотите предоставить всем желающим. Например:

public String getAppletlnfo(){

return "MyApplet v.1.5 P.S.Ivanov";

}

Посмотрим теперь, какие еще параметры можно задать в теге .

Слежение за процессом загрузки

Если вы хотя бы раз видели, как изображение загружается из Internet, то заметили, что оно появляется на экране по частям по мере загрузки. Это происходит в том случае, когда системное свойство awt.image. incrementalDraw имеет значение true.
При поступлении каждой порции изображения браузер вызывает логический метод imageUpdate () интерфейса ImageObserver. Аргументы этого метода содержат информацию о процессе загрузки изображения img. Рассмотрим их:
imageUpdate(Image img, int status, int x, int y, int width, int height);
Аргумент status содержит информацию о загрузке в виде одного целого числа, которое можно сравить со следующими константами интерфейса
ImageObserver:
WIDTH
— ширина уже загруженной части изображения известна, и может быть получена из аргумента width;
HEIGHT
— высота уже загруженной части изображения известна, и может быть получена из аргумента height;'
PROPERTIES
— свойства изображения уже известны, их можно получить методом getProperties{) класса Image;
SOMEBITS
— получены пикселы, достаточные для рисования масштабированной версии изображения; аргументы x, y, width, height определены;
FRAMEBITS
— получен следующий кадр изображения, содержащего несколько кадров; аргументы x, y, width, height не определены;
ALLBITS
— все изображение получено, аргументы x, y, width, height не содержат информации;
ERROR
— загрузка прекращена, рисование прервано, определен бит
ABORT
;
ABORT
— загрузка прервана, рисование приостановлено до прихода следующей порции изображения.
Вы можете переопределить этот метод в своем апплете и использовать его аргументы для слежения за процессом загрузки и определения момента полной загрузки.
Другой способ отследить окончание загрузки — воспользоваться методами класса MediaTracker. Они позволяют проверить, не окончена ли загрузка, или приостановить работу апплета до окончания загрузки. Один экземпляр класса MediaTracker может следить за загрузкой нескольких зарегистрированных в нем изображений.

Сведения об окружении апплета

Метод getCodeBase () возвращает URL-адрес каталога, в котором лежит файл класса апплета.
Метод getoocumentBase () возвращает URL-адрес каталога, в котором лежит HTML-файл, вызвавший апплет.
Браузер реализует интерфейс Appletcontext, находящийся в пакете java.applet. Апплет может получить ссылку на этот интерфейс методом
getAppletContext().
С помощью методов getApplet (String name) и getApplets() интерфейса Appletcontext можно получить ссылку на указанный аргументом name апплет или на все апплеты, загруженные в браузер.
Метод showDocument(URL address) загружает в браузер HTML-файл с адреса address.
Метод showDocument (URL address, String target) загружает файл во фрейм, указанный вторым аргументом target. Этот аргумент может принимать следующие значения:
_seif
— то же окно и тот же фрейм, в котором работает апплет;
_parent
— родительский фрейм апплета;
_top
— фрейм верхнего уровня окна апплета;
_biank
— новое окно верхнего уровня;
name
— фрейм или окно с именем
name
, если оно не существует, то будет создано.

Апплеты были первоначальным практическим применением

Апплеты были первоначальным практическим применением Java. За первые два года существования Java были написаны тысячи очень интересных и красивых апплетов, ожививших WWW. Масса апплетов разбросана по Internet, хорошие примеры апплетов собраны в JDK в каталоге demo\applets.
В JDK вошел целый пакет java.applet, в который фирма SUN собиралась заносить классы, развивающие и улучшающие апплеты.
С увеличением скорости и улучшением качества компьютерных сетей значение апплетов сильно упало. Теперь вся обработка данных, прежде выполняемая апплетами, переносится на сервер, браузер только загружает и показывает результаты этой обработки, становится "тонким клиентом".
С другой стороны, появилось много специализированных программ, в том числе написанных на Java, загружающих информацию из Internet. Такая возможность есть сейчас у всех музыкальных и видеопроигрывателей.
Фирма SUN больше не развивает пакет java.applet. В нем так и остался один класс и три интерфейса. В библиотеку Swing вошел класс JApplet, расширяющий класс Applet. В нем есть дополнительные возможности, например, можно установить систему меню. Он способен использовать все классы библиотеки Swing. Но большинство браузеров еще не имеют Swing в своем составе, поэтому приходится загружать классы Swing с сервера или включать их в jar-архив вместе с классами апплета.

Защита от апплета

Браузер может вообще отказаться от загрузки апплетов. В Netscape Communicator это делается с помощью флажка Enable Java в окне, вызываемом командой Edit | Preferences | Advanced, в Internet Explorer — в окне после выбора команды Tools | Internet Options | Security. В таком случае говорить в этой книге больше не о чем.
Если браузер загружает апплет, то создает ему ограничения, так называемую
"песочницу"
(sandbox), в которой резвится апплет, но выйти из которой не может. Каждый браузер создает свои ограничения, но обычно они заключаются в том, что апплет:
не может обращаться к файловой системе машины, на которой он выполняется, даже для чтения файлов или просмотра каталогов;
может связаться по сети только с тем сайтом, с которого он был загружен;
не может прочитать системные свойства, как это делает, например, приложение в листинге 6.4;
не может печатать на принтере, подключенном к тому компьютеру, на котором он выполняется;
не может воспользоваться буфером обмена (clipboard); не может запустить приложение методом ехес ();
не может использовать "родные" методы или загрузить библиотеку методом load ();
не может остановить JVM методом exit ();
не может создавать классы в пакетах java.*, а классы пакетов sun.* не может даже загружать.
Браузеры могут усилить или ослабить эти ограничения, например, разрешить локальным апплетам, загруженным с той же машины, где они выполняются, доступ к файловой системе. Наименьшие ограничения имеют
доверенные
(trusted) апплеты, снабженные электронной подписью с помощью Классов ИЗ пакетов java.security.*.
При создании приложения, загружающего апплеты, необходимо обеспечить средства проверки апплета и задать ограничения. Их предоставляет класс securityManager. Экземпляр этого класса или его наследника устанавливается в JVM при запуске виртуальной машины статическим методом setSecurityManager(SecurityManager sm) класса System. Обычные приложения не могут использовать данный метод.
Каждый браузер расширяет класс SecurityManager по-своему, устанавливая те или иные ограничения. Единственный экземпляр этого класса создается при запуске JVM в браузере и не может быть изменен.

Иллюстрированный самоучитель по Java

Аффинное преобразование изображения

Класс AffineTransform и его использование подробно разобраны в
главе 9,
здесь мы только применим его для преобразования изображения.
В конструкторе класса AffineTransformOp указывается предварительно созданное аффинное преобразование at и способ интерполяции interp и/или правила визуализации hints:
AffineTransformOp(AffineTransform at, int interp); AffineTransformOp(AffineTransform at, RenderingHints hints);
Способ интерполяции — это одна из двух констант:
TYPE_NEAREST_NEIGHBOR
(по умолчанию во втором конструкторе) или
TYPE_BILINEAR
.
После создания объекта класса
AffineTransformOp
применяется метод
filter
(). При этом изображение преобразуется внутри новой области типа
Bufferedimage
, как показано на рис. 15.6, справа. Сама область выделена черным цветом.
Другой способ аффинного преобразования изображения — применить метод drawlmage(Bufferedlmage img, BufferedlmageOp op, int x, int y) класса Graphics2D. При этом преобразуется вся область img, как продемонстрировано на рис. 15.6, посередине.
В листинге 15.5 показано, как задаются преобразования, представленные на рис. 15.6.
Обратите внимание на особенности работы с Bufferedimage. Надо создать графический контекст изображения и вывести в него изображение. Эти действия кажутся лишними, но удобны для двойной буферизации, которая сейчас стала стандартом перерисовки изображений, а в библиотеке Swing выполняется автоматически.

Листинг 15.5.
Аффинное преобразование изображения
import j ava.awt.*;
import Java.awt.geom.*;
import Java.awt. image.*;
import java.awt.event.*;
public class AffOp extends Frame{
private Bufferedimage bi;
public AffOp(String s){ super (s) ;
// Загружаем изображение
img Image img = getToolkit().getlmage("javalogo52x88.gif");
// В этом блоке организовано ожидание загрузки
try{
MediaTracker mt = new MediaTracker(this);
mt.addlmage(img, 0);
mt.waitForlD(O);
// Ждем окончания загрузки }

catch(Exception e){}

// Размеры создаваемой области bi совпадают

//с размерами изображения img

bi = new Bufferedlmage(img.getWidth(this), img.getHeight(this),

Bufferedlmage.TYPE_INT_RGB);

// Создаем графический контекст big изображения bi

Graphics2D big = bi.createGraphics();

// Выводим изображение img в графический контекст

big big.drawImage(img, 0, 0, this);

}

public void paint(Graphics g){

Graphics2D g2 = (Graphics2D)g;

int w = getSize().width;

int h = getSize().height;

int bw = bi.getWidth(this);

int bh = bi.getHeight(this);

// Создаем аффинное преобразование

at AffineTransform at = new AffineTransform();

at.rotate(Math.PI/4); // Задаем поворот на 45 градусов

//по часовой стрелке вокруг левого верхнего угла.

//Затем сдвигаем изображение вправо на величину bw

at.preConcatenate(new AffineTransform(l, 0, О, 1, bw, 0));

// Определяем область хранения bimg преобразованного

// изображения. Ее размер вдвое больше исходного

Bufferedimage bimg =

new Bufferedlmage(2*bw, 2*bw, Bufferedlmage.TYPE_INT_RGB);

// Создаем объект biop,. содержащий преобразование at

BufferedlmageOp biop = new AffineTransformOp(at,

AffineTransformOp.TYPE_NEAREST_NEIGHBOR);

// Преобразуем изображение, результат заносим в bimg biop.filter(bi, bimg);

// Выводим исходное изображение. g2.drawlmage(bi, null, 10, 30);

// Выводим измененную преобразованием Ыор область bi g2.drawImage(bi, biop, w/4+3, 30);

// Выводим преобразованное внутри области bimg изображение

g2.drawlmage(bimg, null, w/2+3, 30); }

public static void main(String[] args){

Frame f = new AffOpf" Аффинное преобразование");

f.addWindowListener(new WindowAdapter(){

public void windowClosing(WindowEvent e){

System.exit(0);

}

});

f.setSize(400, 200);

f.setVisible(true) ;

}

}

На рис. 15.6 показано исходное изображение, преобразованная область и преобразованное внутри области изображение.

Рис. 15.6. Аффинное преобразование изображения

Анимация

Есть несколько способов создать анимацию. Самый простой из них — записать заранее все необходимые кадры в графические файлы, загрузить их в оперативную память В виде Объектов класса Image или Bufferedlmage и выводить по очереди на экран.
Это сделано в листинге 15.9. Заготовлено десять кадров в файлах runl.gif, run2.gif, , runl0.gif. Они загружаются в массив imgt] и выводятся на экран циклически 100 раз, с задержкой в 0,1 сек.

Листинг 15.9.
Простая анимация
import java.awt.*;
import ]ava.awt.event.*;
class SimpleAnim extends Frame{
private Image[] img = new Image[10];
private int count;
SimpleAnim(String s){ super(s);
MediaTracker tr = new MediaTracker(this);
for (int k = 0; k < 10; k++){
img[k] = getToolkit(}.getlmage("run"+(k+D+".gif");
tr.addlmage(img[k], 0);
)
try{
tr.waitForAll(); // Ждем загрузки всех изображений
}catch(InterruptedException e)(}
setSize(400, 300);
setvisible(true);
},
public void paint(Graphics g){
g.drawImage(img[count % 10], 0, 0, this);
}
// public void update(Graphics g){ paint(g); }
public void go(){ while(count < 100){
repaint(); // Выводим следующий кадр
try{ // Задержка в 0.1 сек
Thread.sleep(100);
}catch(InterruptedException e){)
count++;
}
}
public static void main(String[] args){
SimpleAnim f = new SimpleAnim(" Простая анимация");
f.go();
f.addWindowListener(new WindowAdapter(){
public void windowClosing(WindowEvent ev){
System.exit(0); }
});
}
}
Обратите внимание на следующее важное обстоятельство. Мы не можем обратиться прямо к методу paint () для перерисовки окна компонента, потому что выполнение этого метода связано с операционной системой — метод paint о выполняется автоматически при каждом изменении содержимого окна, его перемещении и изменении размеров. Для запроса на перерисовку окна в классе component есть метод repaint ().

Метод repaint о ждет, когда представится вшможность перер/иеозать

окне,

и потом обращается к методу update (Graphics gj. При этом нескольку обращений к repaint о могут быть произведены исполняющей системой Java за один раз.

Метод update() сначала обращается к методу g.ciearRectO, заполняющему окно цветом фона, а уж затем к методу paint (g). Полный исходный текст таков:

public void update(Graphics g){

if ((this instanceof java.awt.Canvas) ||

(this instanceof java.awt.Panel) ||

(this instanceof java.awt.Frame) ||

(this instanceof java.awt.Dialog) ||

(this instanceof java.awt.Window)){

g.clearRect(0, 0, width, height);

}

paint(g);

}

Если кадры анимации полностью перерисовывают окно, то его очистка методом clearRecto не нужна. Более того, она часто вызывает неприятное мерцание из-за появления на мгновение белого фона. В таком случае надо сделать следующее переопределение:

public void update(Graphics g) {

paint(g);

В листинге 15.9 это переопределение сделано как комментарий.

Для "легких" компонентов дело обстоит сложнее. Метод repaint () последовательно обращается к методам repaint () объемлющих "легких" контейнеров, пока не встретится "тяжелый" контейнер, чаще всего это экземпляр класса Container. В нем вызывается метод update о, очищающий и перерисовывающий контейнер. После этого идет обращение к методам update о всех "легких" компонентов в контейнере.

Отсюда следует, что для устранения мерцания "легких" компонентов необходимо переопределять метод update о первого объемлющего "тяжелого" контейнера, обращаясь в нем к методам super.update (g) или super.paint(g).

Если кадры покрывают только часть окна, причем каждый раз новую, то очистка окна необходима, иначе старые кадры останутся в окне, появится "хвост". Чтобы устранить мерцание, используют прием, получивший название

"двойная буферизация "

(double buffering).

Изменение интенсивности изображения

Изменение интенсивности изображения выражается математически в умножении каждой составляющей цвета на число factor и прибавлении к результату умножения числа offset. Результат приводится к диапазону значений составляющей. После этого интенсивность каждой составляющей цвета линейно изменяется в одном и том же масштабе.
Числа factor и offset постоянны для каждого пиксела и задаются в конструкторе класса вместе с правилами визуализации hints:
RescaleOp(float factor, float^offset, RenderingHints hints) После этого остается применить метод filter ().
На рис. 15.7 интенсивность каждого цвета уменьшена вдвое, в результате белый фон стал серым, а цвета — темнее. Затем интенсивность увеличена на 70 единиц. В листинге 15.6 приведена программа, выполняющая это преобразование.

Листинг 15.6.
Изменение интенсивности изображения
import Java.awt.*;
import j ava.awt.image.*;
import j ava.awt.event.*;
public class Rescale extends Frame{
private Bufferedlmage bi;
public Rescale(String s){
super (s) ;
Image img = getToolkit().getlmage("javalogo52x88.gif");
try{
MediaTracker mt = new MediaTracker(this);
mt.addlmage(img, 0);
mt.waitForlD(O); }
catch(Exception e){}
bi = new Bufferedlmage(img.getWidth(this), img.getHeight(this),
BufferedImage.TYPE_INT_RGB);
Graphics2D big = bi.createGraphics();
big.drawlmage(img, 0, 0, this);
}
public void paint(Graphics g){
Graphics2D g2 = (Graphics2D)g;
int w = getSize().width;
int bw = bi.getWidth(this);
int bh = bi.getHeight(this);
Bufferedlmage bimg =
new Bufferedlmage(bw, bh, BufferedImage.TYPE_INT_RGB);
//——————— Начало определения преобразования --——-———
RescaleOp гор = new RescaleOp(0.5f, 70.Of, null);
rop.filter(bi, bimg);
//——————— Конец определения преобразования ———————
g2.drawlmage(bi, null, 10, 30);
g2.drawlmage(bimg, null, w/2+3, 30);
}
public static void main(String(] args){
Frame f = new Rescale(" Изменение интенсивности");
f.addWindowListener(new WindowAdapter(){
public void windowClosing(WindowEvent e) {
System.exit(0);
}
));
f.setSize(300, 200);
f.setvisible(true);
}
}

Рис. 15.7.
Изменение интенсивности изображения

Изменение составляющих цвета

Чтобы изменить отдельные составляющие цвета, надо прежде всего посмотреть тип хранения элементов в Bufferedimage, по умолчанию это TYPE_INT_RGB. Здесь три составляющие — красная, зеленая и синяя. Каждая составляющая цвета занимает один байт, все они хранятся в одном числе типа int. Затем надо составить таблицу новых значений составляющих. В листинге 15.7 это двумерный массив samples. Потом заполняем данный массив нужными значениями составляющих каждого цвета. В листинге 15.7 задается ярко-красный цвет рисования и белый цвет фона. По полученной таблице создаем экземпляр класса ByteLookupTabie, который свяжет эту таблицу с буфером данных. Этот экземпляр используем для создания объекта класса LookupOp. Наконец, применяем метод filter () этого класса.
В листинге 15.7 приведен только фрагмент программы. Для получения полной программы его надо вставить в листинг 15.6 вместо выделенного в нем фрагмента. Логотип Java будет нарисован ярко-красным цветом.

Листинг 15.7.
Изменение составляющих цвета
//————————————— Вста
вить в листинг 15.6 ————————
byte samples[][] = new byte[3][256];
for (int j = 0; j < 255; j++){
samples[0][j] = (byte)(255); // Красная составляющая
samples[1][j] = (byte)(0); // Зеленая составляющая
samples[2][j] = (byte)(0); // Синяя составляющая
}
samples[0][255] = (byte) (255); // Цвет фона — белый
samples[1][255] = (byte) (255) ;
samples [2] [255] = (bybej (255) ;
ByteLookupTabie blut=new ByteLookupTabie(0, samples);
LookupOp lop = new LookupOp(blut, null);
lop.filter(bi, bimg);
//————————————— Конец вст
авки
———————————————-

Как изменить цвет изображения

В листинге 15.3 меняются цвета каждого пиксела изображения. Это достигается просто сдвигом rgb " 1 содержимого пиксела на один бит вправо в методе fiiterRGB (). При этом усиливается красная составляющая цвета. Метод f iiterRGB о переопределен в расширении coiorFilter класса
RGBImageFilter.

Листинг 15.3.
Изменение цвета всех пикселов ;
import j ava.awt.*;
import java.awt.event.*;
import java.awt.image.*;
class RGBTest extends Frame{
private Image img, newimg;
RGBTest(String s){
super(s);
img = getToolkit().getlmage("javalogo52x88.gif");
RGBImageFilter rgb = new CoiorFilter();
newimg = createlmage(new FilteredlmageSource(img.getSource(), rgb));
setSize(400, 350);
setVisible(true); } public void paint(Graphics g){
g.drawlmage(img, 10, 40, this);
g.drawlmage(newimg, 150, 40, this); }
public static void main(String[] args){
Frame f= new RGBTest(" Изменение цвета");
f.addWindowListener(new WindowAdapter(){
public void wlndowClosing(WindowEvent ev){
System.exit(0);
}
});
)
}
class CoiorFilter extends RGBImageFilter{ CoiorFilter(){
canFilterlndexColorModel = true; }
public int fiiterRGB(int x, int y, int rgb){
return rgb " 1;
}
}

Как переставить пикселы изображения

В листинге 15.4 определяется преобразование пикселов изображения. Создается новый фильтр — расширение shiftFiiter класса imageFilter, сдвигающее изображение циклически вправо на указанное в конструкторе число пикселов. Все, что для этого нужно, — это переопределить метод setPixels().

Листинг 15.4.
Циклический сдвиг изображения
import j ava.awt.*;
import j ava.awt.event.*;
import j ava.awt.image.*;
class Shiftlmage extends Frame{ private Image img, newimg;
Shiftlmage(String
s){
super(s);
// 1. Получаем изображение из файла
img = getToolkit().getlmage("javalogo52x88.gif");
// 2. Создаем экземпляр фильтра
ImageFilter imf = new ShiftFiiter(26);
// Сдвиг на 26 пикселов
// 3. Получаем новые пикселы с помощью фильтра
ImageProducer ip = new FilteredlmageSource(img.getSource(), imf);
// 4. Создаем новое изображение
newimg = createlmage(ip);
setSize(300, 200);
setvisible(true) ; }
public void paint(Graphics gr){
gr.drawlmage(img, 20, 40, this);
gr.drawlmage(newimg, 100, 40, this); }
public static void main(StringU args){
Frame f= new ShiftImage(" Циклический сдвиг изображения");
f.atidWindowListener(new WindowAdapter()(
public void windowClosing(WindowEvent ev){
System.exit(0); )
});
}
}
// Класс-фильтр
class ShiftFilter extends ImageFilterf
private int sh;
// Сдвиг на sh пикселов вправо.
public ShiftFilter(int shift)!{ sh = shift; }
public void setPixels(int x, int y, int w, int h,
ColorModel m, byte[] pix, int off, int size){
for (int k = x; k < x+w; k++){
if (k+sh <= w)
consumer.setPixels(k, y, 1, h, m, pix, off+sh+k, size);
else
consumer.setPixels(k, y, 1, h, m, pix, off+sh+k-w, size);
}
}
}
Как видно из листинга 15.4, переопределение метода setPixels о заключается в том, чтобы изменить аргументы этого метода, переставив, тем самым, пикселы изображения, и передать их потребителю consumer — полю класса imageFiiter методом setPixels о потребителя. На рис. 15.4 показан результат выполнения этой программы.
Вторая модель обработки изображения введена в Java 2D. Она названа моделью
прямого доступа
(immediate mode model).

Риc. 15.4.
Перестановка пикселов изображения

Как выделить фрагмент изображения

В листинге 15.2 выделяется фрагмент изображения и выводится на экран в увеличенном виде. Кроме того, ниже выводятся изображения, увеличенные с помощью классов
RepiicateScaieFiiter и AreaAveragingScaleFilter.

Листинг 15.2.
Примеры масштабирования изображения
import j ava.awt.*;
import j ava.awt.event.*;
import j ava.awt.image.*;
class CropTest extends Frame{
private Image img, cropimg, replimg, averimg;
CropTest(String s){ super (s) ;
// 1. Создаем изображение — объект класса Image
img = getToolkit().getlmage("javalogo52x88.gif");
// 2. Создаем объекты-фильтры:
// а) выделяем левый верхний угол размером 30x30
CropImageFilter crp = new CropImageFilter(0, 0, 30, 30);
// б) увеличиваем изображение в два раза простым методом
RepiicateScaieFiiter rsf = new RepiicateScaieFiiter(104, 176);
// в) увеличиваем изображение в два раза с усреднением
AreaAveragingScaleFilter asf = new AreaAveragingScaleFilter(104, 176);
// 3. Создаем измененные изображения
cropimg = createlmage(new FilteredlmageSource(img.getSource(), crp));
replimg = createlmage(new FilteredlmageSource(img.getSource(), rsf)};
averimg = createlmage(new FilteredlmageSource(img.getSource(), asf));
setSize(400, 350); setvisible(true); }
public void paint(Graphics gS
{
g.drawlmage(img, 10, 40, this);
g.drawlmage(cropimg, 150, 40, 100, 100, this);
g.drawlmage(replimg, 10, 150, this);
g.drawlmage(averimg, 150, 150, this);
}
public static void main(String[] args){
Frame f= new CropTest(" Масштабирование");
f.addWindowListener(new WindowAdapter(){
public void windowClosing(WindowEvent ev){
System.exit(0);
}
});
}
}
На рис. 15.3 слева сверху показано исходное изображение, справа — увеличенный фрагмент, внизу — изображение, увеличенное двумя способами.

Рис. 15.3.
Масштабированное изображение

Классы-фильтры

Интерфейс imageConsumer нет нужды реализовывать, обычно используется его готовая реализация — класс imageFilter. Несмотря на название, этот класс не производит никакой фильтрации, он передает изображение без изменений. Для преобразования изображений данный класс следует расширить, переопределив метод setPixeiso. Результат преобразования следует передать потребителю, роль которого играет поле consumer этого класса.
В пакете java. awt. image есть четыре расширения класса ImageFilter:
CropImageFilter (int x, int у, int w, int h)
— выделяет фрагмент изображения, указанный в приведенном конструкторе;
RGBimageFilter
— позволяет изменять отдельные пикселы; это абстрактный класс, он требует расширения и переопределения своего метода
filterRGBO
;
RepдicateScaieFilter (int w, int h)
— изменяет размеры изображения на указанные в приведенном конструкторе, дублируя строки и/или столбцы при увеличении размеров или убирая некоторые из них при уменьшении;
AreaAveragingScaleFilter (int w, int h)
— расширение предыдущего класса; использует более сложный алгоритм изменения размеров изображения, усредняющий значения соседних пикселов.
Применяются эти классы совместно со вторым классом-поставщиком, реализующим интерфейс ImageProducer — классом FilteredlmageSource. Этот класс преобразует уже готовую продукцию, полученную от другого поставщика producer, используя для преобразования объект filter класса-фильтра imageFilter или его подкласса, Оба объекта задаются в конструкторе
FilteredlmageSource(ImageProducer producer, ImageFilter filter)
Все это кажется очень запутанным, но схема применения фильтров всегда одна и та же. Она показана в листингах 15.2—15.4.

Модель обработки "поставщик-потребитель"

Очень часто изображение перед выводом на экран подвергается обработке: меняются цвета отдельных пикселов или целых участков изображения, выделяются и преобразуются какие-то фрагменты изображения.
В библиотеке AWT применяются две модели обработки изображения. Одна модель реализует давно известную в программировании общую модель "поставщик-потребитель" (Producer-Consumer). Согласно этой модели один объект, "поставщик", генерирует сам или преобразует полученную из другого места продукцию, в данном случае, набор пикселов, и передает другим объектам. Эти объекты, "потребители", принимают продукцию и тоже преобразуют ее при необходимости. Только после этого создается объект класса image и изображение выводится на экран. У одного поставщика может быть несколько потребителей, которые должны быть зарегистрированы поставщиком. Поставщик и потребитель активно взаимодействуют, обращаясь к методам друг друга.
В AWT эта модель описана В двух интерфейсах: ImageProducer И ImageConsumer пакета j ava. awt. image.
Интерфейс ImageProducer описывает пять методов:
addConsumer(ImageConsumer ic)
— регистрирует потребителя ic; removeConsumer (ImageConsumer ic) — отменяет регистрацию;
isConsumer( ImageConsumer ic)
— логический метод, проверяет, зарегистрирован ли потребитель ic;
startProduction (ImageConsumer ic)
— регистрирует потребителя ic И НЭ-чинает поставку изображения всем зарегистрированным потребителям;
requestTopDownLeftRightResend (ImageConsumer ic)
— используется потребителем для того, чтобы затребовать изображение еще раз в порядке "сверху-вниз, слева-направо" для методов обработки, применяющих именно такой порядок.
С каждым экземпляром класса image связан объект, реализующий интерфейс ImageProducer. Его можно получить методом getSource () класса Image.
Самая простая реализация интерфейса ImageProducer — класс метогу-imagesource — создает пикселы в оперативной памяти по массиву байтов или целых чисел. Вначале создается массив pix, содержащий цвет каждой точки. Затем одним из шести конструкторов создается объект класса

MemoryimageSource.

Он может быть обработан потребителем или прямо преобразован в тип Image методом

createlmage ().

В листинге 15.1 приведена простая программа, выводящая на экран квадрат размером 100x100 пикселов. Левый верхний угол квадрата синий, левый нижний — красный, правый верхний — зеленый, а к центру квадрата цвета перемешиваются.



Листинг 15.1.

Изображение, построенное по точкам

import java.awt.*;

import j ava.awt.event.*;

import java.awt.image.*;

class InMemory extends Frame {

private int w = 100, h = 100;

private int[] pix = new int[w * h];

private Image img;

InMemory(String s)( super(s);

int

i =

0;

for (int у = 0; у < h; y++){

int red = 255 * у / (h - 1);

for (int x = 0; x < w; x++){

int green = 255 * x / (w — 1) ;

pix[i++] = (255 << 24)|(red << 16)|(green << 8)| 128; } }

setSize(250, 200);

setVisible(true);

}

public vqid paint(Graphics gr){

if (img == null)

img = createlmage(new MemoryImageSource 0, w));

gr.drawlmage(img, 50, 50, this);

}

public static void main(String[] args){

Frame f= new InMemory(" Изображение в памяти");

f.addWindowListener(new WindowAdapter(){

public void windowClosing(WindowEvent ev){

System.exit (0);

}

});

}

}

В листинге 15.1 в конструктор класса-поставщика MemoryimageSource (w, h, pix, о, w) заносится ширина w и высота h изображения, массив pix, смещение в этом массиве о и длина строки w. Потребителем служит изображение img, которое создается методом createlmage () и выводится на экран методом drawlmage(img, 50, 50, this). Левый верхний угол изображения img располагается в точке (50, 50) контейнера, а последний аргумент this показывает, что роль imageObserver играет сам класс InMemory. Это заставляет включить в метод paint о проверку if (img == null), иначе изображение будет постоянно перерисовываться. Другой способ избежать этого — переопределить метод imageupdate (), о чем говорилось в


главе 14,

просто написав В нем return true.

Рис. 15.1 демонстрирует вывод, этой программы.

Рис. 15.1.

Изображение, созданное по точкам

Интерфейс imageConsumer описывает семь методов, самыми важными из которых являются два метода setPixeis (). Первый:

setPixels(int x, int y, int width, int height, ColorModel model, byte[] pix, int offset, int scansize);

Второй метод отличается только тем, что массив pix содержит элементы типа int.

Рис. 15.2

. Классы, реализующие модель "поставщик-потребитель"

К этим методам обращается поставщик для передачи пикселов потребителю. Передается прямоугольник шириной width и высотой height с заданным верхним левым углом (х, у), заполняемый пикселами из массива pix, начиная с индекса offset. Каждая строка занимает scansize элементов массива pix. Цвета пикселов определяются в цветовой модели model (обычно это модель RGB).

На рис. 15.2 показана иерархия классов, реализующих модель "поставщик-потребитель".

Модель обработки прямым доступом

Подобно тому, как вместо класса Graphics система Java 2D использует его расширение Graphics2D, описанное в
главе 9,
вместо класса image в Java 2D употребляется его расширение — класс Bufferedimage. В конструкторе этого класса
Bufferedlmage(int width, int height, int imageType)
задаются размеры изображения и способ хранения точек — одна из констант:
TYPE_INT_RGB TYPE_4BYTE_ABRG TYPE_USHORT_565_RGB
TYPE_INT_ARGB TYPE_4BYTE_ABRG_PRE TYPE_USHORT_555_RGB
TYPE_INT_ARGB_PRE TYPE_BYTE_GRAY TYPE_USHORT_GRAY
TYPE_INT_BRG TYPE_BYTE_BINARY
TYPE_3BYTE_BRG TYPE_BYTE_INDEXED
Как видите, каждый пиксел может занимать 4 байта — INT, 4BYTE, или 2 байта — USHORT, или 1 байт — BYTE. Может использоваться цветовая модель RGB, или добавлена альфа-составляющая — ARGB, или задан другой порядок расположения цветовых составляющих — BRG, или заданы градации серого цвета — GRAY. Каждая составляющая цвета может занимать один байт, 5 битов или 6 битов.
Экземпляры класса Bufferedimage редко создаются конструкторами. Для их создания чаще обращаются к методам createimage () класса component с простым приведением типа:
Bufferedimage bi = (Bufferedlmage)createimage(width, height)
При этом экземпляр bi получает характеристики компонента: цвет фона и цвет рисования, способ хранения точек.
Расположение точек в изображении регулируется классом Raster или его подклассом WritabieRaster. Эти классы задают систему координат изображения, предоставляют доступ к отдельным пикселам методами getPixeio, позволяют выделять фрагменты изображения методами getPixeiso. Класс WritabieRaster дополнительно разрешает изменять отдельные пикселы методами setPixei () или целые фрагменты изображения методами setPixels () и setRect().
Начало системы координат изображения — левый верхний угол — имеет координаты (minx, minY), не обязательно равные нулю.

При создании экземпляра класса Bufferedimage автоматически формируется связанный с ним экземпляр класса WritabieRaster.

Точки изображения хранятся в скрытом буффе, содержащем одномерный или двумерный массив точек. Вся работа с буфером осуществляется методами одного из классов DataBufferByte, DataBufferlnt, DataBufferShort, DataBufferushort в зависимости от длины данных. Общие свойства этих классов собраны в их абстрактном суперклассе DataBuffer. В нем определены типы данных, хранящихся в буфере:

TYPE_BYTE, TYPEJJSHORT, TYPE_INT, TYPEJJNDEFINED.

Методы класса DataBuffer предоставляют прямой доступ к данным буфера, но удобнее и безопаснее обращаться к ним методами классов Raster и WritableRaster.

При создании экземпляра класса Raster или класса WritableRaster создается экземпляр соответствующего подкласса класса DataBuffer.

Чтобы отвлечься от способа хранения точек изображения, Raster может обращаться не к буферу DataBuffer, а к подклассам абстрактного класса SampieModei, рассматривающим не отдельные байты буфера, а составляющие (samples) цвета. В модели RGB — это красная, зеленая и синяя составляющие. В пакете java.awt. image есть пять подклассов класса SampieModei:

componentsampieModel

— каждая составляющая цвета хранится в отдельном элементе массива DataBuffer;

BandedSampleModel

— данные хранятся по составляющим, составляющие одного цвета хранятся обычно в одном массиве, a

DataBuffer

содержит двумерный массив: по массиву для каждой составляющей; данный класс расширяет класс

ComponentsampieModel

;

PixelInterleavedSampieModel

— все составляющие цвета одного пиксела хранятся в соседних элементах единственного массива

DataBuffer

; данный Класс расширяет класс

ComponentsampieModel

;

MultiPixeiPackedSampieModel

— цвет каждого пиксела содержит только одну составляющую, которая может быть упакована в один элемент массива

DataBuffer

;

singiePixelPackedSampleModel

— все составляющие цвета каждого пиксела хранятся в одном элементе массива


DataBuffer

.

На рис. 15. 5 представлена иерархия классов Java 2D, реализующая модель прямого доступа.

Итак, Java 2D создает сложную и разветвленную трехслойную систему

DataBuffer

—

SampieModei

—

Raster

управления данными изображения

Bufferedimage

. Вы можете манипулировать точками изображения, используя их координаты в методах классов

Raster

или спуститься на уровень ниже и обращаться к составляющим цвета пиксела методами классов

SampieModei

. Если же вам надо работать с отдельными байтами, воспользуйтесь классами

DataBuffer

.

Рис. 15.5.

Классы, реализующие модель прямого доступа

Применять эту систему приходится редко, только при создании своего способа преобразования изображения. Стандартные же преобразования выполняются очень просто.

Преобразование изображения в Java 2D

Преобразование изображения source, хранящегося в объекте класса Buf f redlmage, В новое изображение destination выполняется методом filter(Buffredlmage source, Buffredlmage destination) описанным в интерфейсе BuffredimageOp. Указанный метод возвращает ссылку на новый, измененный объект destination класса Buffredlmage, что позволяет задать цепочку последовательных преобразований.
Можно преобразовать только координатную систему изображения методом filter(Raster source, WritableRaster destination) возвращающим ссылку на измененный объект класса WritableRaster. Данный метод описан в интерфейсе RasterOp.
Способ преобразования определяется классом, реализующим эти интерфейсы, а параметры преобразования задаются в конструкторе класса.
В пакете java.awt.image есть шесть классов, реализующих интерфейсы BuffredimageOp и RasterOp:
AffineTransformOp
— выполняет аффинное преобразование изображения: сдвиг, поворот, отражение, сжатие или растяжение по осям;
RescaieOp
— изменяет интенсивность изображения;
LookupOp
— изменяет отдельные составляющие цвета изображения;
BandCombineOp
— меняет составляющие цвета в Raster;
СolorConvertdp
— изменяет цветовую модель изображения;
ConvolveOp
— выполняет свертку, позволяющую изменить контраст и/или яркость изображения, создать эффект "размытости" и другие эффекты.
Рассмотрим, как можно применить эти классы для преобразования изображения.

в JVM, рассчитан на два

Проигрыватель звука, встроенный в JVM, рассчитан на два способа записи звука: моно и стерео оцифровку (digital audio) с частотой дискретизации (sample rate) от 8 000 до 48 000 Гц и аппроксимацией (quantization) 8 и 16 битов, и MIDI-последовательности (sequences) типа 0 и 1.

Оцифрованный звук должен храниться в файлах типа AU, WAVE и AIFF. Его можно проигрывать двумя способами.

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

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

Перед загрузкой файла надо задать формат записи звука в объекте класса AudioFormat. Конструктор этого класса:

AudioFormat(float sampleRate, int sampleSize, int channels, boolean signed, boolean bigEndian)

требует знания частоты дискретизации sampleRate (по умолчанию 44 100 Гц), аппроксимации sampleSize, заданной в битах (по умолчанию 16), числа каналов channels (1 — моно, по умолчанию 2 — стерео), запись чисел со знаком, signed == true, или без знака, и порядка расположения байтов в числе bigEndian. Такие сведения обычно неизвестны, поэтому их получают косвенным образом из файла. Это осуществляется в два шага.

На первом шаге получаем формат файла статическим методом getAudioFiieFormato класса AudioSystem, на втором — формат записи звука методом getFormato класса AudioFiieFormat. Это описано в листинге 15.15. После того как формат записи определен и занесен в объект класса AudioFormat, в объекте класса DataLine. infо собирается информация о входной линии (line) и способе проигрывания clip или SourceDataLine. Далее следует проверить, сможет ли проигрыватель обслуживать линию с таким форматом. Затем надо связать линию с проигрывателем статическим методом getLine () класса AudioSystem. Потом создаем поток данных из файла — объект класса Audioinputstream. Из этого потока тоже можно извлечь объект класса AudioFormat методом getFormat (). Данный вариант выбран в листинге 15.16. Открываем созданный поток методом орепо.


У-фф! Все готово, теперь можно начать проигрывание методом start (), завершить методом stop(), "перемотать" в начало методом setFramePosition(0) ИЛИ setMillisecondPosition(0).

Можно задать проигрывание п раз подряд методом loop(n) или бесконечное число раз методом

loop (Clip.LOOP_CONTINUOUSLY)

. Перед этим необходимо установить начальную n и конечную m позиции повторения методом

setLoopPoints(n, m).

По окончании проигрывания следует закрыть линию методом close ().

Вся эта последовательность действий показана в листинге 15.15.



Листинг 15.15.

Проигрывание аудиоклипа

import javax.sound.sampled.*;

import java.io.*;

class PlayAudio{

PlayAudio(String s){

play(s);

}

public void play(String file){

Clip line = null;

try{

// Создаем объект, представляющий файл

File f = new File (file);

// Получаем информацию о способе записи файла

AudioFileFormat aff = AudioSystem.getAudioFileFormat(f);

// Получаем информацию о способе записи звука

AudioFormat af = aff.getFormat();

// Собираем всю информацию вместе,

// добавляя сведения о классе

Class DataLine.Infо info = new DataLine.Info(Clip.class, af) ;

// Проверяем, можно ли проигрывать такой формат

if (!AudioSystem.isLineSupported(info)){

System.err.printlnt"Line is not supported");

System.exit(0);

}

// Получаем линию связи с файлом

line = (Clip)AudioSystem.getLine(info);

// Создаем поток байтов из файла

AudioInputStream ais - AudioSystem.getAudioInputStream(f);

// Открываем линию

line.open(ais);

}catch(Exception e){

System.err.println(e);

}

// Начинаем проигрывание

line.start();

// Здесь надо сделать задержку до окончания проигрывания

// или остановить его следующим методом:

line.stop();

//По окончании проигрывания закрываем линию

line.close();

}

public static void main(String[] args){


if (args.length != 1)

System.out.printlnt"Usage: Java PlayAudio filename");

new PlayAudio(args[0]);

}

}

Как видите, методы Java Sound API выполняют элементарные действия, которые надо повторять из программы в программу. Как говорят, это методы "низкого уровня" (low level).

Второй способ, использующий методы интерфейса SourceDataLine, требует предварительного создания буфера произвольного размера.



Листинг 15.16.

Проигрывание аудиофайла

import javax.sound.sampled.*;

import j ava.io.*;

class PlayAudioLine(

PlayAudioLine(String s){

play(s);

}

public void play(String file){

SourceDataLine line = null;

AudioInputStream ais = null;

byte[] b = new byte[2048]; // Буфер данных

try{

File f = new File(file);

// Создаем входной поток байтов из файла f

ais = AudioSystem.getAudioInputStream(f);

// Извлекаем из потока информацию о способе записи звука

AudioFormat af = ais.getFormat () ;

// Заносим эту информацию в объект info

DataLine.Infо info = new DataLine.Infо(SourceDataLine.class, af);

// Проверяем, приемлем ли такой способ записи звука

if (!AudioSystem.isLineSupported(info)){

System.err.println("Line is not supported");

System.exit(0);

}

// Получаем входную линию

line = (SourceDataLine)AudioSystem.getLine(info);

// Открываем линию

line.open(af);

// Начинаем проигрывание

line.start(); // Ждем появления данных в буфере int num = 0;

// Раз за разом заполняем буфер

while(( num = ais.read(b)) != -1)

line.write(b, 0, num);

// "Сливаем" буфер, проигрывая остаток файла

line.drain();

// Закрываем поток

ais.close();

} catch (Exception e) {

System, err.println (e);

}

// Останавливаем проигрывание

line.stop();

// Закрываем линию

line.close();

}


public static void main(String[] args){

String s = "mrmba.aif";

if (args.length > 0) s = args[0];

new PlayAudioLine(s) ;

}

}

Управлять проигрыванием файла можно с помощью событий. Событие класса LineEvent происходит при открытии, OPEN, и закрытии, CLOSE, потока, при начале, START, и окончании, STOP, проигрывания. Характер события отмечается указанными константами. Соответствующий интерфейс LineListener описывает только один метод update ().

В MIDI-файлах хранится

последовательность

(sequence) команд для

секвен-сора

(sequencer) — устройства для записи, проигрывания и редактирования MlDI-последовательности, которым может быть физическое устройство или программа. Последовательность состоит из нескольких

дорожек

(tracks), на которых записаны

MIDI-события

(events). Каждая дорожка загружается в своем

канале

(channel). Обычно дорожка содержит звучание одного музыкального инструмента или запись голоса одного исполнителя или запись нескольких исполнителей, микшированную

синтезатором

(synthesizer).

Для проигрывания MIDI-последовательности в простейшем случае надо создать экземпляр секвенсора, открыть его и направить в него последовательность, извлеченную из файла, как показано в листинге 15.17. После этого следует начать проигрывание методом start (). Закончить проигрывание можно методом stop(), "перемотать" последовательность на начало записи или на указанное время проигрывания — методами setMicrosecondPositionflong mcs) или setTickPosition(long tick).



Листинг 15.17.

Проигрывание MIDI-последовательности

import javax.sound.midi.*;

import j ava.io.*;

class PlayMIDK

PlayMIDKString s) {

play(s);

}

public void play(String file){

try{

File f = new File(file);

// Получаем секвенсор по умолчанию

Sequencer sequencer = MidiSystem.getSequencerО;

// Проверяем, получен ли секвенсор

if (sequencer = null) {

System.err.println("Sequencer is not supported");


System.exit(0);

}

// Открываем секвенсор

sequencer.open();

// Получаем MIDI-последовательность из файла

Sequence seq = MidiSystem.getSequence(f);

// Направляем последовательность в секвенсор

sequencer.setSequence(seq);

// Начинаем проигрывание

sequencer.start();

// Здесь надо сделать задержку на время проигрывания,

// а затем остановить:

sequencer.stop();

)catch(Exception e){

System.err.println(e);

}

}

public static void main(String[] args){

String s = "doom.mid";

if (args.length > 0) s = args[0];

new PlayMIDI(s);

}

}

с микрофона, линейного входа, синтезатора,

Синтез звука заключается в создании MIDI-последовательности — объекта класса sequence — каким-либо способом: с микрофона, линейного входа, синтезатора, из файла, или просто создать в программе, как это делается в листинге 15.18.

Сначала создается пустая последовательность одним из двух конструкторов:

Sequence(float divisionType, int resolution)

Sequence(float divisionType, int resolution, int numTracks)

Первый аргумент divisionType определяет способ отсчета моментов (ticks) MIDI-событий — это одна из констант:

PPQ

(Pulses Per Quarter note) — отсчеты замеряются в долях от длительности звука в четверть;

SMPTE_24, SMPTE_25, SMPTE_so, SMPTE_30DROP

(Society of Motion Picture and Television Engineers) — отсчеты в долях одного кадра, при указанном числе кадров в секунду.

Второй аргумент resolution задает количество отсчетов в указанную единицу, например,

Sequence seq = new Sequence)Sequence.PPQ, 10);

задает 10 отсчетов в звуке длительностью в четверть.

Третий аргумент numTracks определяет количество дорожек в MIDI-после-довательности.

Потом, если применялся первый конструктор, в последовательности создается одна или несколько дорожек:

Track tr = seq.createTrack()

;

Если применялся второй конструктор, то надб получить уже созданные конструктором дорожки:

Track[] trs = seq.getTracks();

Затем дорожки заполняются MIDI-событиями с помощью MIDl-сообще-ний. Есть несколько типов сообщений для разных типов событий. Наиболее часто встречаются сообщения типа shortMessage, которые создаются конструктором по умолчанию и потом заполняются методом setMessageo:

ShortMessage msg = new ShortMessage();

rasg.setMessage(ShortMessage.NOTEJDN, 60, 93);

Первый аргумент указывает тип сообщения:

NOTE_ON

— начать звучание,

NOTE_OFF

— прекратить звучание и т. д. Второй аргумент для типа

NOTE_ОN

показывает высоту звука, в стандарте MIDI это числа от 0 до 127, 60 — нота "до" первой октавы. Третий аргумент означает "скорость" нажатия клавиши MIDI-инструмента и по-разному понимается различными устройствами.


Далее создается MIDI-событие:

MidiEvent me = new MidiEvent{msg, ticks);

Первый аргумент конструктора msg — это сообщение, второй аргумент ticks — время наступления события (в нашем примере проигрывания ноты "до") в единицах последовательности seq (в нашем примере в десятых долях четверти). Время отсчитывается от начала проигрывания последовательности.

Наконец, событие заносится на дорожку:

tr.add(me);

Указанные действия продолжаются, пока все дорожки не будут заполнены всеми событиями. В листинге 15.18 это делается в цикле, но обычно MIDI-события создаются в методах обработки нажатия клавиш на обычной или специальной MIDI-клавиатуре. Еще один способ — вывести на экран изображение клавиатуры и создавать MIDI-собьгшя в методах обработки нажатий кнопки мыши на этой клавиатуре.

После создания последовательности ее можно проиграть, как в листинге 15.17, или записать в файл или выходной поток. Для этого вместо метода start() надо применить метод startRecording (), который одновременно и проигрывает последовательность, и подготавливает ее к записи, которую осуществляют статические методы:

write(Sequence in, int type, File out)

write(Sequence in, int type, OutputStream out)

Второй аргумент type задает тип MIDI-файла, который лучше всего определить для заданной последовательности seq статическим методом getMidiFiieTypes(seq). Данный метод возвращает массив возможных типов. Надо воспользоваться нулевым элементом массива, ,Все это. показало в листинге 15.18.



Листинг 15.18.

Создание MIDI-последовательности нот звукоряда

import javax.sound.midi. *;

import java.io.*;

class SynMIDI {

SynMIDI() {

play(synth());

}

public Sequence synth(){

Sequence seq = null;

try{

// Последовательность будет отсчитывать по 10

// MIDI-событий на Звук длительйостью в четверть

seq = new Sequence(Sequence.PPQ, 10);

// Создаем в последовательности одну дорожку

Track tr = seq.createTrack();


for (int k = 0; k < 100; k++){

ShortMessage msg = new ShortMessage();

// Пробегаем MIDI- ноты от номера 10 до 109

msg.setMessage(ShortMessage.NOTE_ON, 10+k, 93);

// Будем проигрывать ноты через каждые 5 отсчетов

tr.add(new MidiEvent(msg, 5*k));

msg = null;

}

} catch (Exception e) {

System, err.printing "From synth(): "+e);

System.exit (0);

}

return seq;

}

public void play (Sequence seq) {

try{

Sequencer sequencer = MidiSystem.getSequencer();

if (sequencer = null){

System.err.println("Sequencer is not supported");

System.exit(0);

}

sequencer.open();

sequencer.setSequence(seq);

sequencer.startRecording();

int[] type = MidiSystem.getMidiFileTypes(seq);

MidiSystem.write(seq, type[0], new File("gammas.mid"));

}catch(Exception e) {

System.err.println("From play(): " + e);

}

}

public static void main(String[] args)(

new SynMIDI();

}

}

К сожалению, объем книги не позволяет коснуться темы о работе с синтезатором (synthesizer), микширования звука, работы с несколькими инструментами и прочих возможностей Java Sound API. В документации SUN J2SDK, в каталоге docs\guide\sound\prog_guide, есть подробное руководство программиста, а в каталоге demo\sound\src лежат исходные тексты синтезатора, использующего Java Sound API.

Создание различных эффектов

Операция свертки (convolution) задает значение цвета точки в зависимости от цветов окружающих точек следующим образом.
Пусть точка с координатами (х, у) имеет цвет, выражаемый числом А(х, у). Составляем массив из девяти вещественных чисел w(0), w(i), ... w(8). Тогда новое значение цвета точки с координатами (х, у) будет равно:
w(0)*A(x-l, y-l)+w(l)*A(x, y-l)+w(2)*A(x+l, y-l)+
w(3)*A(x-l, y)+w(4)*A(x, y)+w(5)*A(x+l, у)+
w(6)*A(x-l, y+l)+w(7)*A(x, y+l)+w(8)*A(x+l, y+1)
Задавая различные значения весовым коэффициентам w(i), будем получать различные эффекты, усиливая или уменьшая влияние соседних точек.
Если сумма всех девяти чисел w(i) равна 1.0f, то интенсивность цвета останется прежней. Если при этом все веса равны между собой, т. е. равны 0.1111111f, то получим эффект размытости, тумана, дымки. Если вес w(4) значительно больше остальных при общей сумме их l.0f, то возрастет контрастность, возникнет эффект графики, штрихового рисунка.
Можно свернуть не только соседние точки, но и следующие ряды точек, взяв массив весовых коэффициентов из 15 элементов (3x5, 5x3), 25 элементов (5x5) и больше.
В Java 2D свертка делается так. Сначала определяем массив весов, например:
float[] w = (0, -1, О, -1, 5, -1, О, -1, 0};
Затем создаем экземпляр класса Kernel — ядра свертки:
Kernel kern = new Kernel(3, 3, w);
Потом объект класса ConvoiveOp с этим ядром:
ConvolveOp conv = new ConvoiveOp(kern);
Все готово, применяем метод
filter (): conv.filter(bi, bimg);
В листинге 15.8 записаны действия, необходимые для создания эффекта "размытости".

Листинг 15.8.
Создание различных эффектов
//—————————— Вставить в листинг 15.6 ——————————————
float[] wl = { 0.llllllllf, 0.llllllllf, 0.llllllllf,
0.llllllllf, 0.llllllllf, 0.llllllllf,
0.llllllllf, 0.llllllllf, 0.llllllllf };
Kernel kern = new Kernel(3, 3, wl);
ConvolveOp cop = new ConvolveOp(kern, ConvolveOp.EDGE_NO_OP, null);
copl.fliter(bi, bimg) ;
//—————————— Конец вставки ————————————————————
На рис 15.8 представлены слева направо исходное изображение и изображения, преобразованные весовыми матрицами wl, w2 и w3, где матрица wl показана в листинге 15.8, а матрицы w2 и w3 выглядят так:
float[] w2 = { 0, -1, 0,-1, 4, -1, 0, -1, 0 } ;
float[] w3 = { -1, -1, -1,-1, 9, -1, -1, -1, -1 };

Рис. 15.8.
Создание эффектов

Улучшение изображения двойной буферизацией

Суть двойной буферизации в том, что в оперативной памяти создается буфер — объект класса image или Bufferedimage, и вызывается его графический контекст, в котором формируется изображение. Там же происходит очистка буфера, которая тоже не отражается на экране. Только после выполнения всех действий готовое изображение выводится на экран.
Все это происходит в методе updateo, а метод paint о только обращается к update (). Листинги 15.10—15.11 разъясняют данный прием.

Листинг 15.10.
Двойная буферизация с помощью класса image
public void update(Graphics g){
int w = getSize().width, h = getSize().height;
// Создаем изображение-буфер в оперативной памяти
Image offlmg = createlmage(w, h);
// Получаем его графический контекст
Graphics offGr = offImg.getGraphics();
// Меняем текущий цвет буфера на цвет фона
offGr.setColor(getBackground());
//и заполняем им окно компонента, очищая буфер
offGr.fillRect(0, 0, w, h);
// Восстанавливаем текущий цвет буфера
offGr.setColor(getForeground());
// Для листинга 15.9 выводим в контекст изображение
offGr.drawlmage(img[count % 10], 0, 0, this);
// Рисуем в графическом контексте буфера
// (необязательное действие)
paint(offGr);
// Выводим изображение-буфер на экран
// (можно перенести в метод paint())
g.drawlmage(offlmg, 0, 0, this); }
// Метод paint() необязателен
public void paint(Graphics g)J update(g); }

Листинг 15.11.
Двойная буферизация с помощью класса Bufferedimage
public void update(Graphics g){
Graphics2D g2 = (Graphics2D},g;
int w = getSize().width, h = getSize().height;
// Создаем изображение-буфер в оперативной памяти
Bufferedimage bi = (Bufferedimage)createlmage(w, h);
// Создаем графический контекст буфера
Graphics2D big = bi.createGraphics();
// Устанавливаем цвет фона
big.setColor(getBackground());
// Очищаем буфер цветом фона

big.clearRect(0, 0, w, h);

// Восстанавливаем текущий цвет

big.setColor(getForeground());

// Выводим что-нибудь в графический контекст big

// ...

// Выводим буфер на экран

g2.drawImage(bi, 0, 0, this);

}

Метод двойной буферизации стал фактическим стандартом вывода изменяющихся изображений, а в библиотеке Swing он применяется автоматически.

Данный метод удобен и при перерисовке отдельных частей изображения. В этом случае в изображении-буфере рисуется неизменяемая часть изображения, а в методе paint() — то, что меняется при каждой перерисовке.

В листинге 15.12 показан второй способ анимации — кадры изображения рисуются непосредственно в программе, в методе update (), по заданному закону изменения изображения. В результате красный мячик прыгает на фоне изображения.



Листинг 15.12.

Анимация рисованием

import Java.awt.*;

import j ava.awt.event.*;

import Java.awt.geom.*;

import java.awt.image.*;

class DrawAniml extends Frame{

private Image img;

private int count;

DrawAniml(String s) {

super(s);

MediaTracker tr = new MediaTracker(this);

img = getToolkit().getlmage("back2.jpg");

tr.addlmage(img, 0);

try{

tr.waitForlD(0) ;

}catch(InterruptedException e) {}

SetSize(400, 400);

setvisible(true);

}

public void update(Graphics g){

Graphics2D g2 = (Graphics2D)g;

int w = getSizeO.width, h = getSize().height;

Bufferedlmage bi = (Bufferedlmage)createlmage(w, h) ;

Graphics2D big = bi.createGraphics();

// Заполняем фон изображением img

big.drawlmage(img, 0, 0, this);

// Устанавливаем цвет рисования

big.setColor(Color.red);

// Рисуем в графическом контексте буфера круг,

// перемещающийся по синусоиде

big.fill(new Arc2D.Double(4*count, 50+30*Math.sin(count),

50, 50, 0, 360, Arc2D.OPEN));

// Меняем цвет рисования

big.setColor(getForeground());


// Рисуем горизонтальную прямую

big.draw(new Line2D.Double(0, 125, w, 125));

// Выводим изображение-буфер на экран

g2.drawlmage(bi, 0, 0, this); }

public void go(){

while(count < 100){

repaint();

try{

Thread.sleep(10);

}catch(InterruptedException e){}

count++;

}

}

public static void main(String[] args){

DrawAniml f = new DrawAniml(" Анимация");

f.go();

f.addWindowListener(new WindowAdapter(){

public void windowClosing(WindowEvent ev){

System.exit(0);

}

});

}

}

Эффект мерцания, переливы цвета, затемнение и прочие эффекты, получающиеся заменой отдельных пикселов изображения, удобно создавать с помощью класса Memoryimagesource. Методы newPixeis() этого класса вызывают немедленную перерисовку изображения даже без обращения к методу repaint(), если перед этим выполнен метод setAnimated(true). Чаще всего применяются два метода:

newPixels(int x, int y, int width, int height) — получателю посылается указанный аргументами прямоугольный фрагмент изображения;

nevPixels() — получателю посылается все изображение.

В листинге 15.13 показано применение этого способа. Квадрат, выведенный на экран, переливается разными цветами.



Листинг 15.13.

Анимация с помощью MemorylmageSource

import Java.awt.*;

import java.awt.event.*;

import java.awt.image.*;

class InMemory extends Frame{

private int w = 100, h = 100, count;

private int[] pix = new int[w * h];

private Image img;

MemorylmageSource mis;

InMemory(String s){ super(s);

int i = 0;

for(int у = 0; у < h; y++){

int red = 255 * у / (h - 1);

for(int x = 0; x < w; x++){

int green = 25$ * x / (w - 1);

pix[i++] = (255 " 24}|(red << 16)|(green << 8)

|

128;

}

}

mis = new MemorylmageSource(w, h, pix, 0, w);

// Задаем возможность анимации


mis.setAnimated(true);

img = createImage(mis);

setSize(350, 300);

setVisible(true);

}

public void paint(Graphics gr){

gr.drawImage(img, 10, 30, this);

}

public void update(Graphics g)

{

paint(g); }

public void got){

while (count

<

100){

int i = 0;

// Изменяем массив пикселов по некоторому закону

for(int у - 0; у < h;,y++)

for (int

x.

= 0; x < w; x++)

pix[i++J = (255 " 24)|(255 + 8 * count " 16)|

(8*count "8)| 255 + 8 * count;

// Уведомляем потребителя об изменении

mis.newPixels();

try{

Thread.sleep(100);

}catch(InterruptedException e){}

count++;

}

}

public static void main(String[] args){

InMemory f= new InMemory(" Изображение в памяти");

f.go();

f.addWindowListener(new WindowAdapter(){

public void windowClosing(WindowEvent ev){

System.exit(0);

}

));

}

}

Вот и все средства для анимации, остальное — умелое их применение. Комбинируя рассмотренные способы, можно добиться удивительных эффектов. В документации SUN J2SDK, в каталогах demo\applets и demo\jfc\Java2D \src, приведено много примеров апплетов и приложений с анимацией.

Звук

Как было указано в предыдущей главе, в апплетах реализуется интерфейс Audioclip. Экземпляр объекта, реализующего этот интерфейс можно получить методом getAudioClip(), который, кроме того, загружает звуковой файл, а затем пользоваться методами play о, loop о и stop о этого интерфейса для проигрывания музыки.
Для применения данного же приема в приложениях в класс Applet введен статический метод newAudioclp(URL address), загружающий звуковой файл, находящийся по адресу address, и возвращающий объект, реализующий интерфейс Audioclip. Его можно использовать для проигрывания звука в приложении, если конечно звуковая система компьютера уже настроена.
В листинге 15.14 приведено простейшее консольное приложение, бесконечно проигрывающее звуковой файл doom.mid, находящийся в текущем каталоге. Для завершения приложения требуется применить средства операционной системы, например, комбинацию клавиш +.

Листинг 15.14.
Простейшее аудиоприложение
import j ava.applet.* ;
import j ava.net.*;
class SimpleAudio{
SimpleAudio () {
try{
AudioClip ac = Applet.newAudioClip(new URL("file:doom.mid"));
ac.loop();
}catch(Exception e){}
}
public static void main(String[] args){
new SimpleAudio();
}
}
Таким способом можно проигрывать звуковые файлы типов AU, WAVE, AIFF, MIDI без сжатия.
В состав виртуальной машины Java, входящей в SUN J2SDK начиная с версии 1.3, включено устройство, проигрывающее звук, записанный в одном из форматов AU, WAVE, AIFF, MIDI, преобразующее, микширующее и записывающее звук в тех же форматах.
Для работы с этим устройством созданы классы, собранные в пакеты javax.sound.sampled, javax.sound.midi, javax.sound.sampled.spi и javax.sound.midi.spi. Перечисленный набор классов для работы со звуком получил название Java Sound API.

Иллюстрированный самоучитель по Java

Блоки перехвата исключения

Мы можем перехватить и обработать исключение в программе. При описании обработки применяется бейсбольная терминология. Говорят, что исполняющая система или программа "выбрасывает" (throws) объект-исключение. Этот объект "пролетает" через всю программу, появившись сначала в том методе, где произошло исключение, а программа в одном или нескольких местах пытается (try) его "перехватить" (catch) и обработать. Обработку можно сделать полностью в одном месте, а можно обработать исключение в одном месте, выбросить снова, перехватить в другом месте и обрабатывать дальше.
Мы уже много раз в этой книге сталкивались с необходимостью обрабатывать различные исключительные ситуации, но не делали этого, потому что не хотели отвлекаться от основных конструкций языка. Не вводите это в привычку! Хорошо написанные объектно-ориентированные программы обязательно должны обрабатывать все возникающие в них исключительные ситуации.
Для того чтобы попытаться (try) перехватить (catch) объект-исключение, надо весь код программы, в котором может возникнуть исключительная ситуация, охватить оператором try{} catch о {}. Каждый блок catchou перехватывает исключение только одного типа, того, который указан в его аргументе. Но можно написать несколько блоков catch(){} для перехвата нескольких типов исключений.
Например, мы знаем, что в программе листинга 16.1 могут возникнуть исключения двух типов. Напишем блоки их обработки, как это сделано в листинге 16.2.

Листинг 16.2.
Программа с блоками обработки исключений
class SimpleExtlf
public static void main(String[] args){
try{
int n = Integer.parselnt(args[0]);
System.out.println("After parselnt());
System.out.println(" 10 / n = " + (10 / n) ) ;
Systfem. out. println ("After results output");
}catch(ArithmeticException ae){
System.out.println("From Arithm.Exc. catch: "+ae);
}catch(ArraylndexOutOfBoundsException arre){
System.out.println("From Array.Exc.catch: "+arre);

}finally{

System.out.println("From finally");

}

System.out.println("After all actions");

}

}

В программу листинга 16.1 вставлен блок try{} и два блока перехвата catchou для каждого типа исключений. Обработка исключения здесь заключается просто в выводе сообщения и содержимого объекта-исключения, как оно представлено методом tostring() соответствующего класса-исключения.

После блоков перехвата вставлен еще один, необязательный блок finaliy(). Он предназначен для выполнения действий, которые надо выполнить обязательно, чтобы ни случилось. Все, что написано в этом блоке, будет выполнено и при возникновении исключения, и при обычном ходе программы, и даже если выход из блока try{} осуществляется оператором return.

Если в операторе обработки исключений есть блок finally{}, то блок catch () {} может отсутствовать, т. е. можно не перехватывать исключение, но при его возникновении все-таки проделать какие-то обязательные действия.

Кроме блоков перехвата в листинге 16.2 после каждого действия делается трассировочная печать, чтобы можно было проследить за порядком выполнения программы. Программа запущена три раза: с аргументом 5, с аргументом 0 и вообще без аргумента. Результат показан на рис. 16.2.

Рис. 16.2.

Сообщения обработки исключений

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

После второго запуска, приводящего к делению на нуль, управление сразу

Же передается В соответствующий блок catch(ArithmeticException ае) {},

потом выполняется то, что написано в блоке finally{}.

После третьего запуска управление после выполнения метода parseinto передается В другой блок catch(ArraylndexOutOfBoundsException arre){}, затем в блок finally{}.

Обратите внимание, что во всех случаях — и при обычном ходе программы, и после этих обработок — выводится сообщение "After all actions". Это свидетельствует о том, что выполнение программы не прекращается при возникновении исключительной ситуации, как это было в программе листинга 16.1, а продолжается после обработки и выполнения блока finally*}.


При записи блоков обработки исключений надо совершенно четко представлять себе, как будет передаваться управление во всех случаях. Поэтому изучите внимательно рис. 16.2.

Интересно, что пустой блок catch (){}, в котором между фигурными скобками нет ничего, даже пробела, тоже считается обработкой исключения и приводит к тому, что выполнение программы не прекратится. Именно так мы "обрабатывали" исключения в предыдущих главах.

Немного выше было сказано, что выброшенное исключение "пролетает" через всю программу. Что это означает? Изменим программу листинга 16.2, вынеся деление в отдельный метод f (). Получим листинг 16.3.



Листинг 16.3.

Выбрасывание исключения из метода

class SimpleExt2{

private static void f(int n){

System.out.println(" 10 / n = " + (10 / n));

}

public static void main(String[] args){

try{

int n = Integer.parselnt(args[0]);

System.out.println("After parselnt());

f (n);

System.out.println("After results output");

}catch(SrithmeticException ae){

System.out.println("From Arithm.Exc. catch: "+ae);

}catch(ArraylndexQutOfBoundsException arre){

System.out.println("From Array.Exc. catch: "+arre);

}finally{

System,out.println("From finally");

}

System.out.println("After all actions");

}

}

Откомпилировав и запустив программу листинга 16.3, убедимся, что вывод программы не изменился, он такой же, как на рис. 16.2. Исключение, возникшее при делении на нуль в методе f (), "пролетело" через этот метод, "вылетело" в метод main (), там перехвачено и обработано.

Часть заголовка метода throws

То обстоятельство, что метод не обрабатывает возникающее в нем исключение, а выбрасывает (throws) его, следует отмечать в заголовке метода служебным словом throws и указанием класса исключения:
private static void f(int n) throws ArithmeticException{
System.out.println(" 10 / n = " + (10 / n)) ;
}
Почему же мы не сделали это в листинге 16.3? Дело в том, что спецификация JLS делит все исключения на
проверяемые
(checked), те, которые проверяет компилятор, и
непроверяемые
(unchecked). При проверке компилятор замечает необработанные в методах и конструкторах исключения и считает ошибкой отсутствие в заголовке таких методов и конструкторов пометки throws. Именно для предотвращения подобных ошибок мы в предыдущих главах вставляли в листинги блоки обработки исключений.
Так вот, исключения класса RuntimeException и его подклассов, одним из которых является ArithmeticException, непроверяемые, для них пометка throws необязательна. Еще одно большое семейство непроверяемых исключений составляет класс Error и его расширения.
Почему компилятор не проверяет эти типы исключений? Причина в том, что исключения класса RuntimeException свидетельствуют об ошибках в программе, и единственно разумный метод их обработки — исправить исходный текст программы и перекомпилировать ее. Что касается класса Error, то эти исключения очень трудно локализовать и на стадии компиляции невозможно определить место их появления.
Напротив, возникновение проверяемого исключения показывает, что программа недостаточно продумана, не все возможные ситуации описаны. Такая программа должна быть доработана, о чем и напоминает компилятор.
Если метод или конструктор выбрасывает несколько исключений, то их надо перечислить через запятую после слова throws. Заголовок метода main ()
листинга 16.1, если бы исключения, которые он выбрасывает, не были бы объектами подклассов класса RuntimeException, следовало бы написать так:
public static void main(String[] args)
throws ArithmeticException, ArrayIndexOutOfBoundsException{

// Содержимое метода

}

Перенесем теперь обработку деления на нуль в метод f о и добавим трассировочную печать, как это сделано в листинге 16.4. Результат — на рис. 16.3.



Листинг 16.4.

Обработка исключения в методе

class SimpleExt3{

private static void f(int n){ // throws ArithmeticException{

try{

System.out.println(" 10 / n = " + (10 / n) ) ;

System.out.printlnt"From f() after results output");

}catch(ArithmeticException ae)(

System.out.printlnf"From f() catch: " + ae) ;

// throw ae;

}finally{

System.out.println("From f() finally");

}

}

public static void main(String[] args){

try{

inf n = Integer.parselnt(args[0]);

System.out.printlnt"After parselnt());

f (n);

System.out.println("After results output"); (

catch(ArithmeticException ae){

System.out.println("From Arithm.Exc. catch: "+ае);

}catch(ArraylndexOutOfBoundsException arre)(

System.out.println("From Array.Exc. catch: "+arre);

}finally{

System.out.println("From finally");

}

System.out.println("After all actions");

}

}

Внимательно проследите за передачей управления и заметьте, что исключение класса ArithmeticException уже не выбрасывается в метод main ().

Оператор try {}catch о {} в методе f о можно рассматривать как вложенный в оператор обработки исключений в методе main ().

При необходимости исключение можно выбросить оператором throw ae. В листинге 16.4 этот оператор показан как комментарий. Уберите символы комментария //, перекомпилируйте программу и посмотрите, как изменится ее вывод.

Рис. 16.3.

Обработка исключения в методе

Иерархия классов-исключений

Все классы-исключения расширяют класс Throwabie — непосредственное расширение класса object.
У класса Throwabie и у всех его расширений по традиции два конструктора:
Throwabie о — конструктор по умолчанию;
Throwabie (String message) — создаваемый объект будет содержать произвольное сообщение message.
Записанное в конструкторе сообщение можно получить затем методом getMessage (). Если объект создавался конструктором по умолчанию, то данный метод возвратит null.
Метод tostringo возвращает краткое описание события, именно он работал в предыдущих листингах.
Три метода выводят сообщения обо всех методах, встретившихся по пути "полета" исключения:
printstackTrace() — выводит сообщения в стандартный вывод, как правило, это консоль;
printStackTrace(PrintStream stream) — выводит сообщения в байтовый поток stream;
printStackTrace(PrintWriter stream) — выводит сообщения в символьный поток stream.
У класса Throwabie два непосредственных наследника — классы Error и Exception. Они не добавляют новых методов, а служат для разделения классов-исключений на два больших семейства — семейство классов-ошибок (error) и семейство собственно классов-исключений (exception).
Классы-ошибки, расширяющие класс Error, свидетельствуют о возникновении сложных ситуаций в виртуальной машине Java. Их обработка требует глубокого понимания всех тонкостей работы JVM. Ее не рекомендуется выполнять в обычной программе. Не советуют даже выбрасывать ошибки оператором throw. He следует делать свои классы-исключения расширениями класса Error или какого-то его подкласса.
Имена классов-ошибок, по соглашению, заканчиваются словом Error.
Классы-исключения, расширяющие класс Exception, отмечают возникновение обычной нештатной ситуации, которую можно и даже нужно обработать. Такие исключения следует выбросить оператором throw. Классов-исключений очень много, более двухсот. Они разбросаны буквально по всем пакетам J2SDK. В большинстве случаев вы способны подобрать готовый класс-исключение для обработки исключительных ситуаций в своей программе. При желании можно создать и свой класс-исключение, расширив класс Exception или любой его подкласс.
Среди классов-исключений выделяется класс RuntimeException — прямое расширение класса Exception. В нем и его подклассах отмечаются исключения, возникшие при работе JVM, но не столь серьезные, как ошибки. Их можно обрабатывать и выбрасывать, расширять своими классами, но лучше
доверить это JVM, поскольку чаще всего это просто ошибка в программе, которую надо исправить. Особенность исключений данного класса в том, что их не надо отмечать в заголовке метода пометкой throws.
Имена классов-исключений, по соглашению, заканчиваются словом Exception.

Оператор throw

Этот оператор очень прост: после слова throw через пробел записывается объект класса-исключения. Достаточно часто он создается прямо в операторе throw, например:
throw new ArithmeticException();
Оператор можно записать в любом месте программы. Он немедленно выбрасывает записанный в нем объект-исключение и дальше обработка этого исключения идет как обычно, будто бы здесь произошло деление на нуль или другое действие, вызвавшее исключение класса ArithmeticException.
Итак, каждый блок catch о и перехватывает один определенный тип исключений. Если требуется одинаково обработать несколько типов исключений, то можно воспользоваться тем, что классы-исключения образуют иерархию. Изменим еще раз листинг 16.2, получив листинг 16.5.

Листинг 16.5.
Обработка нескольких типов исключений
class SimpleExt4(
public static void main(String[] args){
try{
int n = Integer.parselnt(args[0]);
System.out.println("After parselnt());
System.out.println(" 10 / n = " + (10 / n) ) ;
System.out.println("After results output");
}catch(RuntimeException ae){
System.out.println("From Run.Exc. catch: "+ae);
}finally{
System.out.println("From finally");
}
System.out.println("After all actions");
}
}
В листинге 16.5 два блока catch() {} заменены одним блоком, перехватывающим исключение класса RuntimeException. Как видно на рис. 16.4, этот блок перехватывает оба исключения. Почему? Потому что это исключения подклассов класса RuntimeException.

Рис. 16.4.
Перехват нескольких типов исключений
Таким образом, перемещаясь по иерархии классов-исключений, мы можем обрабатывать сразу более или менее крупные совокупности исключений. Рассмотрим подробнее иерархию классов-исключений.

Порядок обработки исключений

Блоки catch () {} перехватывают исключения в порядке написания этих блоков. Это правило приводит к интересным результатам.
В листинге 16.2 мы записали два блока перехвата catchou и оба блока выполнялись при возникновении соответствующего исключения. Это происходило по тому, что классы-исключения ArithmeticException и ArrayindexOutofBoundsException находятся на разных ветвях иерархии исключений. Иначе обстоит дело, если блоки catch() {} перехватывают исключения, расположенные на одной ветви. Если в листинге 16.4 после блока, перехватывающего RuntimeException, поместить блок, обрабатывающий выход индекса за пределы:
try{
// Операторы, вызывающие исключения
}catch(RuntimeException re){
// Какая-то обработка
}catch(ArrayindexOutofBoundsException ae){
// Никогда не будет выполнен!
}
то он не будет выполняться, поскольку исключение этого типа является, к тому же, исключением общего типа RuntimeException и будет перехватываться Предыдущим блоком catch () {}.

Создание собственных исключений

Прежде всего, нужно четко определить ситуации, в которых будет возникать ваше собственное исключение, и подумать, не станет ли его перехват невольно перехватывать также и другие, не учтенные вами исключения.
Потом надо выбрать суперкласс создаваемого класса-исключения. Им может быть класс Exception или один из его многочисленных подклассов.
После этого можно написать класс-исключение. Его имя, по соглашению, должно завершаться словом Exception. Как правило, этот класс состоит только из двух конструкторов и переопределения методов tostringo и getMessageO.
Рассмотрим простой пример. Пусть метод handle(int cipher) обрабатывает арабские цифры 0—9, которые передаются ему в аргументе cipher типа int.
Мы хотим выбросить исключение, если аргумент cipher выходит за диапазон 0—9.
Прежде всего, убедимся, что такого исключения нет в иерархии классов Exception. Ко всему прочему, не отслеживается и более общая ситуация попадания целого числа в какой-то диапазон. Поэтому будем расширять наш класс. Назовем его cipherException, прямо от класса Exception. Определим класс cipherException, как показано в листинге 16.6, и используем его в классе ExceptDemo. На рис. 16.5 продемонстрирован вывод этой программы.

Листинг 16.6.
Создание класса-исключения
class CipherException extends Exception{
private String msg;
CipherException(){ msg = null;}
CipherException(String s){ msg = s;}
public String toString(){
return "CipherException (" + msg + ");
}
}
class Except Demo(
static public void handle(int cipher) throws CipherException{
System.out.pnntln("handle()'s beginning");
if (cipher < 0 || cipher > 9)
throw new CipherException("" + cipher);
System.out.println("handle()'s ending");
}
public static void main(String[] args){
try{
handle(1) ;
handle(10);
}catch(CipherException ce){
System.out.println("caught " + ce) ;
ce.printStackTrace();
}
}
}

Рис. 16.5.
Обработка собственного исключения

Обработка исключительных ситуаций стала сейчас

Обработка исключительных ситуаций стала сейчас обязательной частью объектно-ориентированных программ. Применяя методы классов J2SDK и других пакетов, обращайте внимание на то, какие исключения они выбрасывают, и обрабатывайте их. Исключения резко меняют ход выполнения программы, делают его запутанным. Не увлекайтесь сложной обработкой, помните о принципе KISS.
Например, из блока finally!} можно выбросить исключение и обработать его в другом месте. Подумайте, что произойдет в этом случае с исключением, возникшем в блоке try{}? Оно нигде не будет перехвачено и обработано.

Иллюстрированный самоучитель по Java

Группы подпроцессов

Подпроцессы объединяются в группы. В начале работы программы исполняющая система Java создает группу подпроцессов с именем main. Все подпроцессы по умолчанию попадают в эту группу.
В любое время программа может создать новые группы подпроцессов и подпроцессы, входящие в эти группы. Вначале создается группа — экземпляр класса ThreadGroup, конструктором
ThreadGroup(String name)
При этом группа получает имя, заданное аргументом name. Затем этот экземпляр указывается при создании подпроцессов в конструкторах класса Thread. Все подпроцессы попадут в группу с именем, заданным при создании группы.
Группы подпроцессов могут образовать иерархию. Одна группа порождается от другой конструктором
ThreadGroup(ThreadGroup parent, String name)
Группы подпроцессов используются главным образом для задания приоритетов подпроцессам внутри группы. Изменение приоритетов внутри группы не будет влиять на приоритеты подпроцессов вне иерархии этой группы. Каждая группа имеет максимальный приоритет, устанавливаемый методом setMaxPriorityfint maxPri) класса ThreadGroup. Ни один подпроцесс из этой группы не может превысить значения maxPri, но приоритеты подпроцессов, заданные до установки maxPri, не меняются.

Класс Thread

В классе Thread семь конструкторов:
Thread(ThreadGroup group, Runnabie target, String name)
— создает ПОД-процесс с именем name, принадлежащий группе group и выполняющий метод run о объекта target. Это основной конструктор, все остальные обращаются к нему с тем или иным параметром, равным null;
Thread ()
— создаваемый подпроцесс будет выполнять свой метод run ();
Thread(Runnabie target);
Thread(Runnabie target, String name);
Thread(String name);
Thread(ThreadGroup group, Runnabie target);
Thread(ThreadGroup group, String name).
Имя подпроцесса name не имеет никакого значения, оно не используется, виртуальной машиной Java и применяется только для различения подпроцессов в программе.
После создания подпроцесса его надо запустить методом start (). Виртуальная машина Java начнет выполнять метод run () этого объекта-подпроцесса.
Подпроцесс завершит работу после выполнения метода run (). Для уничтожения объекта-подпроцесса вслед за этим он должен присвоить значение null.
Выполняющийся подпроцесс можно приостановить статическим методом sleep (long ms) на ms миллисекунд. Этот метод мы уже использовали в предыдущих главах. Если вычислительная система может отсчитывать наносекунды, то можно приостановить подпроцесс с точностью до наносекунд методом sleep(long ms, int nanosec).
В листинге 17.1 приведен простейший пример. Главный подпроцесс создает два подпроцесса с именами Thread i и Thread 2, выполняющих один и тот же метод run (). Этот метод просто выводит 20 раз текст на экран, а затем сообщает о своем завершении.

Листинг 17.1.
Два подпроцесса, запущенных из главного подпроцесса
class OutThread extends Thread{
private String msg;
OutThread(String s, String name){
super(name); msg = s;
}
public void run()
{
for(int i = 0; i < 20; i++){
// try{
// Thread.sleep(100);
// }catch(InterruptedException ie){}
System.out.print(msg + " ");
}

System.out.println("End of " + getName());

}

} class TwoThreads{

public static void main(String[] args){

new OutThread("HIP", "Thread 1").start();

new OutThread("hop", "Thread 2").start();

System.out.println();

}

}

На рис. 17. 1 показан результат двух запусков программы листинга 17.1. Как видите, в первом случае подпроцесс Thread i успел отработать полностью до переключения процессора на выполнение второго подпроцесса. Во втором случае работа подпроцесса Thread

i

была прервана, процессор переключился на выполнение подпроцесса Thread 2, успел выполнить его полностью, а затем переключился обратно на выполнение подпроцесса Thread i и завершил его.

Рис. 17.1.

Два подпроцесса работают без задержки

Уберем в листинге 17.1 комментарии, задержав тем самым выполнение каждой итерации цикла на 0,1 секунды. Пустая обработка исключения InterruptedException означает, что мы игнорируем попытку прерывания работы подпроцесса. На рис. 17.2 показан результат двух запусков программы. Как видите, процессор переключается с одного подпроцесса на другой, но в одном месте регулярность переключения нарушается и ранее запущенный подпроцесс завершается позднее.

Рис. 17.2.

Подпроцессы работают с задержкой

Как же добиться согласованности, как говорят,

синхронизации

(synchronization) подпроцессов? Обсудим это ниже, а пока покажем еще два варианта создания той же самой программы.

В листинге 17.2 приведен второй вариант той же программы: сам класс TwoThreads2 является расширением класса Thread, а метод run () реализуется прямо в нем.



Листинг 17.2.

Класс расширяет Thread

class TwoThreads2 extends Thread{

private String msg;

TwoThreads2(String s, String name){

super(name); msg = s;

}

public void run(){

for(int i = 0; i < 20; i++){

try{

Thread.sleep(100);

}catch(InterruptedException ie){}


System.out.print(msg + " ");

}

System.out.println("End of " + getName());

}

public static void main(String[] args)(

new TwoThreads2("HIP", "Thread 1").start();

new TwoThreads2("hop", "Thread 2").start();

System.out.println();

}

}

Третий вариант: класс TwoThreads3 реализует интерфейс Runnabie. Этот вариант записан в листинге 17.3. Здесь нельзя использовать методы класса Thread, но зато класс TwoThreads3 может быть расширением другого класса. Например, можно сделать его апплетом, расширив класс Applet или JAppiet.



Листинг 17.3.

Реализация интерфейса Runnabie

class TwoThreadsS implements Runnabie{

private String msg;

TwoThreads3(String s){ msg = s; }

public void run(){

forfint i = 0; i < 20; i++){

try{

Thread.sleep(100);

}catch(InterruptedException ie){}

System.out.print(msg + " ");

}

System.out.println("End of thread.");

}

public static void main (String[] args){

new Thread(new TwoThreads3("HIP"), "Thread 1").start ();

new Thread(new TwoThreads3("hop"), "Thread 2").start ();

System.out.println();

}

}

Чаще всего в новом подпроцессе задаются бесконечные действия, выполняющиеся на фоне основных действий: проигрывается музыка, на экране вращается анимированный логотип фирмы, бежит рекламная строка. Для реализации такого подпроцесса в методе run о задается бесконечный цикл, останавливаемый после того, как объект-подпроцесс получит значение null.

В листинге 17.4 показан четвертый вариант той же самой программы, в которой метод runt) выполняется до тех пор, пока текущий объект-подпроцесс th совпадает с объектом до, запустившим текущий подпроцесс. Для прекращения его выполнения предусмотрен метод stop (), к которому обращается главный подпроцесс. Это стандартная конструкция, рекомендуемая документацией J2SDK. Главный подпроцесс в данном примере только создает объекты-подпроцессы, ждет одну секунду и останавливает их.




Листинг 17.4.

Прекращение работы подпроцессов

class TwoThreadsS implements Runnabie{

private String msg;

private Thread go;

TwoThreadsS(String s){

msg = s;

go = new Thread(this);

go.start();

}

public void run(){

Thread th = Thread.currentThread();

while(go == th){

try{

Thread.sleep(100);

}catch(InterruptedException ie){}

System.out.print(msg + " ");

}

System.out.println("End of thread.");

}

public void stop(){ go = null; }

public static void main(String[] args){

TwoThreadsS thl = new TwoThreadsS("HIP");

TwoThreadsS th2 = new TwoThreadsS("hop");

try{

Thread.sleep(1000);

}catch(InterruptedException ie){}

thl.stop(); th2.stop();

System.out.printlnf);

}

}

Подпроцессы-демоны

Работа программы начинается с выполнения метода main о главным подпроцессом. Этот подпроцесс может породить другие подпроцессы, они, в свою очередь, способны породить свои подпроцессы. После этого главный подпроцесс ничем не будет отличаться от остальных подпроцессов. Он не следит за порожденными им подпроцессами, не ждет от них никаких сигналов. Главный подпроцесс может завершиться, а программа будет продолжать работу, пока не закончит работу последний подпроцесс.
Это правило не всегда удобно. Например, какой-то из подпроцессов может приостановиться, ожидая сетевого соединения, которое никак не может наступить. Пользователь, не дождавшись соединения, прекращает работу главного подпроцесса, но программа продолжает работать.
Такие случаи можно учесть, объявив некоторые подпроцессы
демонами
(daemons). Это понятие не совпадает с понятием демона в UNIX. Просто программа завершается по окончании работы последнего
пользовательского
(user) подпроцесса, не дожидаясь окончания работы демонов. Демоны будут принудительно завершены исполняющей системой Java.
Объявить подпроцесс демоном можно сразу после его создания, перед запуском. Это делается методом setoaemon(true). Данный метод обращается к методу checkAccess () И МОЖEТ выбросить SecurityException.
Изменить статус демона после запуска процесса уже нельзя.
Все подпроцессы, порожденные демоном, тоже будут демонами. Для изменения их статуса необходимо обратиться к методу setoaemon(false).

Приоритеты подпроцессов

Планировщик подпроцессов виртуальной машины Java назначает каждому подпроцессу одинаковое время выполнения процессором, переключаясь с подпроцесса на подпроцесс по истечении этого времени. Иногда необходимо выделить какому-то подпроцессу больше или меньше времени по сравнению с другим подпроцессом. В таком случае можно задать подпроцессу больший или меньший приоритет.
В классе Thread есть три целые статические константы, задающие приоритеты:
NORM_PRIORITY
— обычный приоритет, который получает каждый подпроцесс при запуске, его числовое значение 5;
MIN_PRIORITY
— наименьший приоритет, его значение 1;
MAX_PRIORITY
— наивысший приоритет, его значение 10.
Кроме этих значений можно задать любое промежуточное значение от 1 до 10, но надо помнить о том, что процессор будет переключаться между подпроцессами с одинаковым высшим приоритетом, а подпроцессы с меньшим приоритетом не станут выполняться, если только не приостановлены все подпроцессы с высшим приоритетом. Поэтому для повышения общей производительности следует приостанавливать время от времени методом sleep о подпроцессы с высоким приоритетом.
Установить тот или иной приоритет можно в любое время методом setPriorityfint newPriority), если подпроцесс имеет право изменить свой приоритет. Проверить наличие такого права можно методом checkAtcess(). Этот метод выбрасывает исключение класса Security&xception, если подпроцесс не может изменить свой приоритет.
Порожденные подпроцессы будут иметь тот же приоритет, что и подпроцесс-родитель.
Итак, подпроцессы, как правило, должны работать с приоритетом
NORM_PRIORITY
. Подпроцессы, большую часть времени ожидающие наступления какого-нибудь события, например, нажатия пользователем кнопки Выход, могут получить более высокий приоритет
MAX_PRIORITY
. Подпроцессы, выполняющие длительную работу, например, установку сетевого соединения или отрисовку изображения в памяти при двойной буферизации, могут работать с низшим приоритетом
MIN_PRIORITY
.

Синхронизация подпроцессов

Основная сложность при написании программ, в которых работают несколько подпроцессов — это согласовать совместную работу подпроцессов с общими ячейками памяти.
Классический пример — банковская транзакция, в которой изменяется остаток на счету клиента с номером numDep. Предположим, что для ее выполнения запрограммированы такие действия:
Deposit myDep = getDeposit(numDep); // Получаем счет с номером numDep
int rest = myDep.getRest(); // Получаем остаток на счету myDep
Deposit newDep = myDep.operate(rest, sum); // Изменяем остаток
// на величину sum
myDep.setDeposit(newDep); // Заносим новый остаток на счет myDep
Пусть на счету лежит 1000 рублей. Мы решили снять со счета 500 рублей, а в это же время поступил почтовый перевод на 1500 рублей. Эти действия выполняют разные подпроцессы, но изменяют они один и тот же счет myDep с номером numDep. Посмотрев еще раз на рис. 17.1 и 17.2, вы поверите, что последовательность действий может сложиться так. Первый подпроцесс проделает вычитание 1000-500, в это время второй подпроцесс выполнит все три действия и запишет на счет 1000+1500 = 2500 рублей, после чего первый подпроцесс выполнит свое последнее действие и у нас на счету окажется 500 рублей. Вряд ли вам понравится такое выполнение двух транзакций.
В языке Java принят выход из этого положения, называемый в теории операционных систем
монитором
(monitor). Он заключается в том, что подпроцесс блокирует объект, с которым работает, чтобы другие подпроцессы не могли обратиться к данному объекту, пока блокировка не будет снята. В нашем примере первый подпроцесс должен вначале заблокировать счет myDep, затем полностью выполнить всю транзакцию и снять блокировку. Второй подпроцесс приостановится и станет ждать, пока блокировка не будет снята, после чего начнет работать с объектом myDep.

Все это делается одним оператором synchronized () {}, как показано ниже:

Deposit myDep = getDeposit(numDep); synchronized(myDep){

int rest = myDep.getRest();

Deposit newDep = myDep.operate(rest, sum);

myDep.setDeposit(newDep);

}

В заголовке оператора synchronized в скобках указывается ссылка на объект, который будет заблокирован перед выполнением блока. Объект будет недоступен для других подпроцессов, пока выполняется блок. После выполнения блока блокировка снимается.

Если при написании какого-нибудь метода оказалось, что в блок synchronized входят все операторы этого метода, то можно просто пометить метод-словом synchronized, сделав его

синхронизированным

(synchronized):

synchronized int getRest()(

// Тело метода

}

synchronized Deposit operate(int rest, int sum) {

// Тело метода

}

synchronized void setDeposit(Deposit dep){

// Тело метода

}

В этом случае блокируется объект, выполняющий метод, т. е. this. Если все методы, к которым не должны одновременно обращаться несколько подпроцессов, помечены synchronized, то оператор synchronized () (} уже не нужен. Теперь, если один подпроцесс выполняет синхронизированный метод объекта, то другие подпроцессы уже не могут обратиться ни к одному синхронизированному методу того же самого объекта.

Приведем простейший пример. Метод run о в листинге 17.5 выводит строку "Hello, World!" с задержкой в 1 секунду между словами. Этот метод выполняется двумя подпроцессами, работающими с одним объектом th. Программа выполняется два раза. Первый раз метод run () не синхронизирован, второй раз синхронизирован, его заголовок показан в листинге 17.4 как комментарий. Результат выполнения программы представлен на рис. 17.3.



Листинг 17.5.

Синхронизация метода

class TwoThreads4 implements Runnable{

public void run(){

// synchronized public void run(){

System.out.print("Hello, ");

try{

Thread.sleep(1000);


}catch(InterruptedException ie){}

System.out.println("World!");

}

public static void main(String[] args){

TwoThreads4 th = new TwoThreads4();

new Thread(th).start();

new Thread(th).start();

}

}

Рис. 17.3.

Синхронизация метода

Действия, входящие в синхронизированный блок или метод образуют

критический участок

(critical section) программы. Несколько подпроцессов, собирающихся выполнять критический участок, встают в очередь. Это замедляет работу программы, поэтому для быстроты ее выполнения критических участков должно быть как можно меньше, и они должны быть как можно короче.

Многие методы Java 2 SDK синхронизированы. Обратите внимание, что на рис. 17.1 слова выводятся вперемешку, но каждое слово выводится полностью. Это происходит потому, что метод print о класса Printstream синхронизирован, при его выполнении выходной поток system, out блокируется до тех пор, пока метод print () не закончит свою работу.

Итак, мы можем легко организовать последовательный доступ нескольких подпроцессов к полям одного объекта с помощью оператора synchronized () {}. Синхронизация обеспечивает

взаимно исключающее

(mutually exclusive) выполнение подпроцессов. Но что делать, если нужен совместный доступ нескольких подпроцессов к общим объектам? Для этого в Java существует механизм ожидания и уведомления (wait-notify).

Согласование работы нескольких подпроцессов

Возможность создания многопоточных программ заложена в язык Java с самого его создания. В каждом объекте есть три метода wait о и один метод notify о, позволяющие приостановить работу подпроцесса с этим объектом, позволить другому подпроцессу поработать с объектом, а затем уведомить (notify) первый подпроцесс о возможности продолжения работы. Эти методы определены прямо в классе object и наследуются всеми классами.
С каждым объектом связано множество подпроцессов, ожидающих доступа к объекту (wait set). Вначале этот "зал ожидания" пуст.
Основной метод wait (long miiiisec) приостанавливает текущий подпроцесс this, работающий с объектом, на miiiisec миллисекунд и переводит его в "зал ожидания", в множество ожидающих подпроцессов. Обращение к этому методу допускается только в синхронизированном блоке или методе, чтобы быть уверенными в том, что с объектом работает только один подпроцесс. По истечении miiiisec или после того, как объект получит уведомление методом notify о, подпроцесс готов возобновить работу. Если аргумент miiiisec равен о, то время ожидания не определено и возобновление работы подпроцесса возможно только после того, как объект получит уведомление методом notify().
Отличие данного метода от метода sleep о в том, что метод wait о снимает блокировку с объекта. С объектом может работать один из подпроцессов из "зала ожидания", обычно тот, который ждал дольше всех, хотя это не гарантируется спецификацией JLS.
Второй метод wait () эквивалентен wait (0). Третий метод wait (long millisec, int nanosec) уточняет задержку на nanosec наносекунд, если их сумеет отсчитать операционная система.
Метод notify () выводит из "зала ожидания" только один, произвольно выбранный подпроцесс. Метод notifyAll() выводит из состояния ожидания все подпроцессы. Эти методы тоже должны выполняться в синхронизированном блоке или методе.
Как же применить все это для согласованного доступа к объекту? Как всегда, лучше всего объяснить это на примере.

Обратимся снова к схеме "поставщик-потребитель", уже использованной в

главе 15.

Один подпроцесс, поставщик, производит вычисления, другой, потребитель, ожидает результаты этих вычислений и использует их по мере поступления. Подпроцессы передают информацию через общий экземпляр st класса store.

Работа этих подпроцессов должна быть согласована. Потребитель обязан ждать, пока поставщик не занесет результат вычислений в объект st, а поставщик должен ждать, пока потребитель не возьмет этот результат.

Для простоты поставщик просто заносит в общий объект класса store целые числа, а потребитель лишь забирает их.

В листинге 17.6 класс store не обеспечивает согласования получения и выдачи информации. Результат работы показан на рис. 17.4.



Листинг 17.6.

Несогласованные подпроцессы

class Store{

private inf inform;

synchronized public int getlnform(){ return inform; }

synchronized public void setlnform(int n){ inform = n; }

}

class Producer implements Runnable{

private Store st;

private Thread go;

Producer(Store st){

this.st = st;

go = new Thread(this);

go.start();

}

public void run(){

int n = 0;

Thread th = Thread.currentThread();

while(go == th){

st.setlnform(n);

System.out.print("Put: " + n + " ");

n++;

}

}

public void stop(){ go = null;

}

}

class Consumer implements Runnable{

private Store st;

private Thread go;

Consumer(Store st){

this.st = st;

go =-new Thread(this);

go.start () ;

}

public void run(){

Thread th = Thread.currentThread();

while(go == th) System.out.println("Got: " + st.getlnformf));

}

public void stop(){ go = null; }

}

class ProdCons{

public static void main(String[] args){

Store st = new Store();

Producer p = new Producer(st);


Consumer с = new Consumer(st);

try{

Thread.sleep(30);

}catch(InterruptedException ie){}

p.stop(); c.stop();

}

}

Рис. 17.4.

Несогласованная работа двух подпроцессов

В листинге 17.7 в класс store внесено логическое поле ready, отмечающее процесс получения и выдачи информации. Когда новая порция информации получена от поставщика Producer, в поле ready заносится значение true, получатель consumer может забирать эту порцию информации. После выдачи информации переменная ready становится равной false.

Но этого мало. То, что получатель может забрать продукт, не означает, что он действительно заберет его. Поэтому в конце метода setinformf) получатель уведомляется о поступлении продукта методом notify о. Пока поле ready не примет нужное значение, подпроцесс переводится в "зал ожидания" методом wait (). Результат работы программы с обновленным классом store показан на рис. 17.5.



Листинг 17.7.

Согласование получения и выдачи информации

class Store{

private int inform = -1;

private boolean ready;

synchronized public int getlnform(){

try{

if (! ready) wait();

ready = false;

return inform;

}catch(InterruptedException ie){

}finally!

notify();

}

return -1;

}

synchronized public void setlnform(int n)(

if (ready)

try{

wait ();

}catch(InterruptedException ie){}

inform = n;

ready = true;

notify();

}

}

Поскольку уведомление поставщика в методе getinformo должно происходить уже после отправки информации оператором return inform, оно включено В блок finally{}

Рис. 17.5.

Согласованная работа подпроцессов

Обратите внимание: сообщение "Got: 0" отстает на один шаг от действительного получения информации.

Технология Java по своей сути

Технология Java по своей сути — многозадачная технология, основанная на threads. Это одна из причин, по которым технология Java так и не может разумным образом реализоваться в MS-DOS и Windows 3.1, несмотря на многие попытки.
Поэтому, конструируя программу для Java, следует все время помнить, что она будет выполняться в многозадачной среде. Надо ясно представлять себе, что будет, если программа начнет выполняться одновременно несколькими подпроцессами, выделять критические участки и синхронизировать их.
С другой стороны, если программа осуществляет несколько действий, следует подумать, не сделать ли их выполнение одновременным, создав дополнительные подпроцессы и распределив их приоритеты.

Иллюстрированный самоучитель по Java

Буферизованный ввод/вывод

Операции ввода/вывода по сравнению с операциями в оперативной памяти выполняются очень медленно. Для компенсации в оперативной памяти выделяется некоторая промежуточная область — буфер, в которой постепенно накапливается информация. Когда буфер заполнен, его содержимое быстро переносится процессором, буфер очищается и снова заполняется информацией.
Житейский пример буфера — почтовый ящик, в котором накапливаются письма. Мы бросаем в него письмо и уходим по своим делам, не дожидаясь приезда почтовой машины. Почтовая машина периодически очищает почтовый ящик, перенося сразу большое число писем. Представьте себе город, в котором нет почтовых ящиков, и толпа людей с письмами в руках дожидается приезда почтовой машины.
Классы файлового ввода/вывода не занимаются буферизацией. Для этой цели есть четыре специальных класса BufferedXxx, перечисленных выше. Они присоединяются к потокам ввода/вывода как "переходное кольцо", например:
BufferedReader br = new BufferedReader(isr);
BufferedWriter bw = new BufferedWriter(fw);
Потоки isr и fw определены выше.
Программа листинга 18.3 читает текстовый файл, написанный в кодировке СР866, и записывает его содержимое в файл в кодировке KOI8_R. При чтении и записи применяется буферизация. Имя исходного файла задается в командной строке параметром args[0], имя копии — параметром argstl].

Листинг 18.3.
Буферизованный файловый ввод/вывод
import java.io.*;
class DOStoUNIX{
public static void main(String[] args) throws IOException{
if (args.length != 2){
System.err.println("Usage: DOStoUNIX Cp866file KOI8_Rfile");
System.exit(0);
}
BufferedReader br = new BufferedReader(
new InputStreamReader(
new FileInputStream(args[0]), "Cp866"));
BufferedWriter bw = new BufferedWriter(
new OutputStreamWriter(
new FileOutputStreamtargs[1]), "KOI8_R"));
int с = 0;
while ((c = br.readO) != -1)
bw.write((char)c);
br.closeO; bw.close();
System.out.println("The job's finished.");
}
}

Файловый ввод/вывод

Поскольку файлы в большинстве современных операционных систем понимаются как последовательность байтов, для файлового ввода/вывода создаются байтовые потоки с помощью классов Fiieinputstream и FiieOutputstream. Это особенно удобно для бинарных файлов, хранящих байт-коды, архивы, изображения, звук.
Но очень много файлов содержат тексты, составленные из символов. Несмотря на то, что символы могут храниться в кодировке Unicode, эти тексты чаще всего записаны в байтовых кодировках. Поэтому и для текстовых файлов можно использовать байтовые потоки. В таком случае со стороны программы придется организовать преобразование байтов в символы и обратно.
Чтобы облегчить это преобразование, в пакет java.io введены классы FineReader и FileWriter. Они организуют преобразование потока: со стороны программы потоки символьные, со стороны файла — байтовые. Это происходит потому, что данные классы расширяют классы InputStreamReader и OutputstreamWriter, соответственно, значит, содержат "переходное кольцо" внутри себя.
Несмотря на различие потоков, использование классов файлового ввода/вывода очень похоже.
В конструкторах всех четырех файловых потоков задается имя файла в виде строки типа string или ссылка на объект класса File. Конструкторы не только создают объект, но и отыскивают файл и открывают его. Например:
Fileinputstream fis = new FilelnputStreamC'PrWr.Java");
FileReader fr = new FileReader("D:\\jdkl.3\\src\\PrWr.Java");
При неудаче выбрасывается исключение класса FileNotFoundException, но конструктор класса FileWriter выбрасывает более общее исключение
IOException.
После открытия выходного потока типа FileWriter или FileQutputStEeam содержимое файла, если он был не пуст, стирается. Для того чтобы можно было делать запись в конец файла, и в том и в другом классе предусмотрен конструктор с двумя аргументами. Если второй аргумент равен true, то происходит дозапись в конец файла, если false, то файл заполняется новой информацией. Например:

FileWriter fw = new FileWriter("ch!8.txt", true);

FileOutputstream fos = new FileOutputstream("D:\\samples\\newfile.txt");





Внимание



Содержимое файла, открытого на запись конструктором с одним аргументом, стирается.

Сразу после выполнения конструктора можно читать файл:

fis.read(); fr.read();

или записывать в него:

fos.write((char)с); fw.write((char)с);

По окончании работы с файлом поток следует закрыть методом close ().

Преобразование потоков в классах FileReader и FileWriter выполняется по кодовым таблицам установленной на компьютере локали. Для правильного ввода кирилицы надо применять FileReader, a нe FileInputStream. Если файл содержит текст в кодировке, отличной от локальной кодировки, то придется вставлять "переходное кольцо" вручную, как это делалось для консоли, например:

InputStreamReader isr = new InputStreamReader(fis, "KOI8_R"));

Байтовый поток fis определен выше.

Каналы обмена информацией

В предыдущей главе мы видели, каких трудов стоит организовать правильный обмен информацией между подпроцессами. В пакете java.io есть четыре класса pipedxxx, облегчающие эту задачу.
В одном подпроцессе — источнике информации — создается объект класса PipedWriter+ или PipedOutputstream, в который записывается информация методами write () этих классов.
В другом .подпроцессе —приемнике информации — формируется объект класса PipedReader или Pipedinputstream. Он связывается с объектом-источником с помощью конструктора или специальным методом connect (), и читает информацию методами read ().
Источник и приемник можно создать и связать в обратном порядке.
Так создается однонаправленный
канал
(pipe) информации. На самом деле это некоторая область оперативной памяти, к которой организован совместный доступ двух или более подпроцессов. Доступ синхронизируется, записывающие процессы не могут помешать чтению.
Если надо организовать двусторонний обмен информацией, то создаются два канала.
В листинге 18.5 метод run о класса source генерирует информацию, для простоты просто целые числа k, и передает £е в канал методом pw. write (k). Метод run() класса Target читает информацию из канала методом pr.read(). Концы канала связываются с помощью конструктора класса Target. На рис. 18.6 видна последовательность записи и чтения информации.

Листинг 18.5.
Канал обмена информацией
import java.io.*;
class Target extends Thread{
private PipedReader pr;
Target(PipedWriter pw){
try{
pr = new PipedReader(pw);
}catch(lOException e){
System.err.println("From Target(): " + e);
}
}
PipedReader getStream(){ return pr;}
public void run(){
while(true)
try{
System.out.println("Reading: " + pr.read());
}catch(IOException e){
System.out.println("The job's finished.");
System.exit(0);
}
}
}
class Source extends Thread{

private PipedWriter pw;

Source (){

pw = new PipedWriter();

}

PipedWriter getStream(){ return pw;}

public void run(){

for (int k = 0; k < 10; k++)

try{

pw.write(k);

System.out.println("Writing: " + k);

}catch(Exception e){

System.err.printlnf"From Source.run(): " + e) ;

}

}

}

class PipedPrWr{

public static void main(String[] args){

Source s = new Source();

Target t = new Target(s.getStream());

s.start();

t.start();

}

)

Рис. 18.6.

Данные, передаваемые между подпроцессами

в байтовой кодировке вызывает трудности

Запись потока в байтовой кодировке вызывает трудности с использованием национальных символов, запись потока в Unicode увеличивает длину потока в два раза. Кодировка UTF-8 (Universal Transfer Format) является компромиссом. Символ в этой кодировке записывается одним, двумя или тремя байтами.

Символы Unicode из диапазона '\u0000' —'\u007F', в котором лежит английский алфавит, записываются одним байтом, старший байт просто отбрасывается.

Символы Unicode из диапазона '\u0080' —'\u07FF', в котором лежат наиболее распространенные символы национальных алфавитов, записываются двумя байтами следующим образом: символ Unicode с кодировкой 00000хххххуууууу записывается как 110ххххх10уууууу.

Остальные символы Unicode из диапазона '\u0800' —'\UFFFF' записываются тремя байтами по следующему правилу: символ Unicode с кодировкой xxxxyyyyyyzzzzzz записывается как 1110xxxx10yyyyyy10zzzzzz.

Такой странный способ распределения битов позволяет по первым битам кода узнать, сколько байтов составляет код символа, и правильно отсчитывать символы в потоке.

Так вот, метод writeUTF( string s) сначала записывает в поток в первые два байта потока длину строки s в кодировке UTF-8, а затем символы строки в этой кодировке. Читать эту запись потом следует парным методом readUTF() класса DatalnputStream.

Класс DatalnputStream преобразует входной поток байтов типа InputStream, составляющих данные простых типов Java, в данные этого типа. Такой поток, как правило, создается методами класса DataOutputstream. Данные из этого потока можно прочитать методами readBoolean(), readByte(), readShort(), readChar(), readlnt(), readLong(), readFloat(), readDouble(), возвращающими данные соответствующего типа.

Кроме того, методы readUnsignedByteO H readUnsignedShort () возвращают целое типа int, в котором старшие три или два байта нулевые, а младшие один или два байта заполнены байтами из входного потока.

Метод readUTF(), двойственный методу writeUTF(), возвращает строку типа string, полученную из потока, записанного методом writeUTF ().


Еще один, статический, метод readUTF( Datainput in) делает то же самое со входным потоком in, записанным в кодировке UTF-8. Этот метод можно применять, не создавая объект класса DatalnputStream.

Программа в листинге 18.4 записывает в файл fib.txt числа Фибоначчи, а затем читает этот файл и выводит его содержимое на консоль. Для контроля записываемые в файл числа тоже выводятся на консоль. На рис. 1S.5 рока-зан вывод этой программы.



Листинг 18.4.

Ввод/вывод данных

import j ava.io.*;

class DataPrWr{

public static void main(String[] args) throws IOException{

DataOutputstream dos = new DataOutputstream (

new FileOutputStream("fib.txt"));

int a = 1, b = 1, с = 1;

for (int k = 0; k < 40; k++){

System.out.print(b + " ");

dos.writelnt(b);

a = b; b = с; с = a + b;

}

dos.closet);

System.out.println("\n");

DatalnputStream dis = new DatalnputStream (

new FilelnputStream("fib.txt")) ;

while(true)

try{

a = dis.readlnt();

System.out.print(a + " ">;

}catch(lOException e){

dis.close();

System.out.println("End of file");

System.exit (0);

}

}

}

Обратите внимание на то, что попытка чтения за концом файла выбрасывает исключение класса IOException, его обработка заключается в закрытии файла и окончании программы.

Рис. 18.5.

Ввод и вывод данных

Консольный ввод/вывод

Для вывода на консоль мы всегда использовали метод printino класса Pnntstream, никогда не определяя экземпляры этого класса. Мы просто использовали статическое поле out класса system, которое является объектом класса PrintStream. Исполняющая система Java связывает это поле с консолью.
Кстати говоря, если вам надоело писать system.out.printino, то вы можете определить новую ссылку на system, out, например:
PrintStream pr - System.out;
и писать просто pr. printin ().
Консоль является байтовым устройством, и символы Unicode перед выводом на консоль должны быть преобразованы в байты. Для символов Latin 1 с кодами '\u0000' — '\u00FF' при этом просто откидывается нулевой старший байт и выводятся байты '0х00' —'0xFF'. Для кодов кириллицы, которые лежат в диапазоне '\u0400
1
—'\u04FF
1
кодировки Unicode, и других национальных алфавитов производится преобразование по кодовой таблице, соответствующей установленной на компьютере л окал и. Мы обсуждали это в
главе 5.
Трудности с отображением кириллицы возникают, если вывод на консоль производится в кодировке, отличной от локали. Именно так происходит в русифицированных версиях MS Windows NT/2000. Обычно в них устанавливается локаль с кодовой страницей СР1251, а вывод на консоль происходит в кодировке СР866.
В этом случае надо заменить Printstream, который не может работать с сим- , вольным потоком, на Printwriter и "вставить переходное кольцо" между потоком символов Unicode и потоком байтов system, out, выводимых на консоль, в виде объекта класса OutputstreamWriter. В конструкторе этого объекта следует указать нужную кодировку, в данном случае, СР866. Все это можно сделать одним оператором:
PrintWriter pw = new PrintWriter(
new OutputstreamWriter(System.out, "Cp866"), true);
Класс Printstream буферизует выходной поток. Второй аргумент true его конструктора вызывает принудительный сброс содержимого буфера в выходной поток после каждого выполнения метода printin(). Но после print() буфер не сбрасывается! Для сброса буфера после каждого print() надо писать flush(), как это сделано в листинге 18.2.





Замечание



Методы класса PrintWriter по умолчанию не очищают буфер, а метод print () не очищает его в любом случае. Для очистки буфера используйте метод flush().

После этого можно выводить любой текст методами класса PrintWriter, которые просто дублируют методы класса Printstream, и писать, например,

pw.println("Это русский текст");

как показано в листинге 18.1 и на рис. 18.3.

Следует заметить, что конструктор класса PrintWriter, в котором задан байтовый поток, всегда неявно создает объект класса OutputstreamWriter с локальной кодировкой для преобразования байтового потока в символьный поток.

Ввод с консоли производится методами read о класса inputstream с помощью статического поля in класса system. С консоли идет поток байтов, полученных из scan-кодов клавиатуры. Эти байты должны быть преобразованы в символы Unicode такими же кодовыми таблицами, как и при выводе на консоль. Преобразование идет по той же схеме — для правильного ввода кириллицы удобнее всего определить экземпляр класса BufferedReader, используя в качестве "переходного кольца" объект класса inputstreamReader:

BufferedReader br = new BufferedReader(

new InputstreamReader(System.an, "Cp866"));

Класс BufferedReader переопределяет три метода read о своего суперкласса Reader. Кроме того, он содержит метод readLine ().

Метод readLine о возвращает строку типа string, содержащую символы входного потока, начиная с текущего, и заканчивая символом '\п' и/или '\r'. Эти символы-разделители не входят в возвращаемую строку. Если во входном потоке нет символов, то возвращается null.

В листинге 18.1 приведена программа, иллюстрирующая перечисленные методы консольного ввода/вывода. На рис. 18.3 показан вывод этой программы.



Листинг 18.1.

Консольный ввод/вывод

import j ava.io.*;

class PrWr{

public static void main(String[] args){

try{

BufferedReader br =

new BufferedReader(new InputstreamReader(System.in, "Cp866"));


PrintWriter pw = new PrintWriter(

new OutputstreamWriter(System.out, "Cp866"), true);

String s = "Это строка с русским текстом";

System.out.println("System.out puts: " + s);

pw.println("PrintWriter puts: " + s) ;

int с = 0;

pw.println("Посимвольный ввод:");

while((с = br.read()) != -1)

pw.println((char)c);

pw.println("Построчный ввод:");

do{

s = br.readLine();

pw.println(s);

}while(!s.equals("q"));

}catch(Exception e){

System.out.println(e);

}

}

}

Поясним рис. 18.3. Первая строка выводится потоком system.out. Как видите, кириллица выводится неправильно. Следующая строка предварительно преобразована в поток байтов, записанных в кодировке СР866.

Затем, после текста "Посимвольный ввод:" с консоли вводятся символы "Россия" и нажимается клавиша . Каждый вводимый символ отображается на экране — операционная система работает в режиме так называемого "эха". Фактический ввод с консоли начинается только после нажатия клавиши , потому что клавиатурный ввод буферизуется операционной системой. Символы сразу после ввода отображаются по одному на строке. Обратите внимание на две пустые строки после буквы я. Это выведены символы '\п' и '\г', которые попали во входной поток при нажатии клавиши . У них нет никакого графического начертания (glyph).

Потом нажата комбинация клавиш +. Она отображается на консоль как "^Z" и означает окончание клавиатурного ввода, завершая цикл ввода символов. Коды этих клавиш уже не попадают во входной поток.

Далее, после текста "Построчный ввод:" с клавиатуры набирается строка "Это строка" и, вслед за нажатием клавиши , заносится в строку s. Затем строка s выводится обратно на консоль.

Для окончания работы набираем q и нажимаем клавишу .

Рис. 18.3.

Консольный ввод/вывод

Печать файла

Печать текстового файла заключается в размещении его строк в графическом контексте методом drawstring (). При этом необходимо проследить за правильным размещением строк в области печати и разбиением файла на страницы.
В листинге 18.9 приведен упрощенный пример печати текстового файла, имя которого задается в командной строке. Из файла читаются готовые строки, программа не сравнивает их длину с шириной области печати, не выделяет абзацы. Вывод производится в локальной кодировке.

Листинг 18.9.
Печать текстового файла
import java.awt.*;
import java.awt.print.*;
import java.io.* ;
public class Print2File{
public static void main(String[] args){
if (args.length < 1){
System.err.println("Usage: Print2File path");
System, exit(0);
}
PrinterJob pj = PrinterJob.getPrinterJob();
PageFormat pf = pj.pageDialog(pj.defaultPage());
pj.setPrintable(new FilePagePainter(args[0]), pf);
if (pj.printDialog()){
try{
pj.print();
}catch(PrinterException e){}
)
System, exit(0);
}
}
class FilePagePainter implements Printable{
private BufferedReader br;
private String file;
private int page = -1;
private boolean eof;
private String[] line;
private int numLines;
public FilePagePainter(String file){
this.file = file;
try{
br = new BufferedReader(new FileReader(file));
}catch(IOException e){ eof = true; }
}
public int print(Graphics g, PageFormat pf, int ind)
throws PrinterException(
g.setColor(Color.black);
g.setFont(new Font("Serif", Font.PLAIN, 10));
int h = (int)pf.getlmageableHeight();
int x = (int)pf.getlmageableX() + 10;
int у = (int)pf.getlmageableY() + 12;
try{
// Если система печати запросила эту страницу первый раз
if (ind != page){
if (eof) return Printable.NO_SUCH_PAGE;
page = ind;
line = new String[h/12]; // Массив строк на странице

numLines =0; // Число строк на странице

// Читаем строки из файла и формируем массив строк

while (у + 48 < pf.getlmageableY() + h){

line[numLines] = br.readLine();

if (line[numLines] == null){

eof = true; break; }

numLines++;

У += 12;

}

}

// Размещаем колонтитул

у = (int)pf.getImageableY() + 12;

g.drawstring("Файл: " + file + ", страница " +

(ind + 1), x, у);

// Оставляем две пустые строки

у += 36;

// Размещаем строки текста текущей страницы

for (int i = 0; i < numLines; i++){

g.drawString(line[i], x, y) ;

у += 12;

}

return Printable.PAGE_EXISTS;

}catch(lOException e){

return Printable.NO_SUCH_PAGE;

}

}

}

Печать средствами Java 2D

Расширенная графическая система Java 2D предлагает новые интерфейсы и классы для печати, собранные в пакет java.awt.print. Эти классы полностью перекрывают все стандартные возможности печати библиотеки AWT. Более того, они удобнее в работе и предлагают дополнительные возможности. Если этот пакет установлен в вашей вычислительной системе, то, безусловно, нужно применять его, а не стандартные средства печати AWT.
Как и стандартные средства AWT, методы классов Java 2D выводят на печать содержимое графического контекста, заполненного методами класса
Graphics
или класса
Graphics2D.
Всякий класс Java 2D, собирающийся печатать хотя бы одну страницу текста, графики или изображения называется классом,
рисующим страницы
(page painter). Такой класс должен реализовать интерфейс Printable. В этом интерфейсе описаны две константы и только один метод print о. Класс, рисующий страницы, должен реализовать этот метод. Метод print о возвращает целое типа int и имеет три аргумента:
print(Graphics g, PageFormat pf, int ind);
Первый аргумент g — это графический контекст, выводимый на лист бумаги, второй аргумент pf — экземпляр класса PageFormat, определяющий размер и ориентацию страницы, третий аргумент ind — порядковый номер страницы, начинающийся с нуля.
Метод print () класса, рисующего страницы, заменяет собой метод paint (), использовавшийся стандартными средствами печати AWT. Класс, рисующий страницы, не обязан расширять класс Frame и переопределять метод paint (). Все заполнение графического контекста методами класса Graphics или Graphics2D теперь выполняется в методе print ().
Когда печать страницы будет закончена, метод print () должен возвратить целое значение, заданное константой PAGE_EXISTS. Будет сделано повторное обращение к методу print () для печати следующей страницы. Аргумент ind при этом возрастет на 1. Когда ind превысит количество страниц, метод print о должен возвратить значение NO_SUCH_PAGE, что служит сигналом окончания печати.
Следует помнить, что система печати может несколько раз обратиться к методу paint () для печати одной и той же страницы. При этом аргумент ind не меняется, а метод print () должен создать тот же графический контекст.

Класс PageFormat определяет параметры страницы. На странице вводится система координат с единицей длины 1/72 дюйма, начало которой и направление осей определяется одной из трех констант:

PORTRAIT

— начало координат расположено в левом верхнем углу страницы, ось Ох направлена вправо, ось Оу — вниз;

LANDSCAPE

— начало координат в левом нижнем углу, ось Ох идет вверх, ось Оу — вправо;

REVERSE_LANDSCAPE

— начало координат в правом верхнем углу, ось Ох идет вниз, ось Оу — влево.

Большинство принтеров не может печатать без полей, на всей странице, а осуществляет вывод только в некоторой

области печати

(imageable area), координаты левого верхнего угла которой возвращаются методами getimageabiex() и getlmageableY(), а ширина и высота — методами getlmageableWidth() и getlmageableHeight().

Эти значения надо учитывать при расположении элементов в графическом контексте, например, при размещении строк текста методом drawstring (), как это сделано в листинге 18.9.

В классе только один конструктор по умолчанию PageFormat о, задающий стандартные параметры страницы, определенные для принтера по умолчанию вычислительной системы.

Читатель, добравшийся до этого места книги, уже настолько поднаторел в Java, что у него возникает вопрос: "Как же тогда задать параметры страницы?" Ответ простой: "С помощью стандартного окна операционной системы".

Метод pageDiaiog(PageDiaiog pd) открывает на экране стандартное окно Параметры страницы (Page Setup) операционной системы, в котором уже заданы параметры, определенные в объекте pd. Если пользователь выбрал в этом окне кнопку Отмена, то возвращается ссылка на объект pd, если кнопку ОК, то создается и возвращается ссылка на новый объект. Объект pd в любом случае не меняется. Он обычно создается конструктором.

Можно задать параметры страницы и из программы, но тогда следует сначала определить объект класса Paper конструктором по умолчанию:

Paper р = new Paper()


Затем методами

p.setSize(double width, double height)

p.setlmageableArea( double x, double y, double width, double height)

задать размер страницы и области печати.

Потом определить объект класса pageFormat с параметрами по умолчанию:

PageFormat pf = new PageFormat()

и задать новые параметры методом

pf.setPaper(p)

Теперь вызывать на экран окно Параметры страницы методом pageDiaiogo уже не обязательно, и мы получим

молчаливый

(silent) процесс печати. Так делается в тех случаях, когда печать выполняется на фоне отдельным подпроцессом.

Итак, параметры страницы определены, метод print о — тоже. Теперь надо дать

задание на печать

(print job) — указать количество страниц, их номера, порядок печати страниц, количество копий. Все эти сведения собираются в классе Printer Job.

Система печати Java 2D различает два вида заданий. В более простых заданиях — Printable Job — есть только один класс, рисующий страницы, поэтому у всех страниц одни и те же параметры, страницы печатаются последовательно с первой по последнюю или с последней страницы по первую, это зависит от системы печати.

Второй, более сложный вид заданий — Pageable Job — определяет для печати каждой страницы свой класс, рисующий страницы, поэтому у каждой страницы могут быть собственные параметры. Кроме того, можно печатать не все, а только выбранные страницы, выводить их в обратном порядке, печатать на обеих сторонах листа. Для осуществления этих возможностей определяется экземпляр класса Book или создается класс, реализующий интерфейс Pageable.

В классе Book, опять-таки, один конструктор, создающий пустой объект:

Book b = new Book()

После создания в данный объект добавляются классы, рисующие страницы. Для этого в классе Book есть два метода:

append (Printable p, PageFormat pf) —добавляет объект р В конец;

append(Printable p, PageFormat pf, int numPages) — добавляет numPages

экземпляров р в конец; если число страниц заранее неизвестно, то задается константа

UNKNOWN_NUMBER_OF_PAGES


.

При составлении задания на печать, т. е. после создания экземпляра класса PrinterJob, надо указать вид задания одним и только одним из трех методов ЭТОГО класса setPrintable(Printable pr), setPrintable(Printable pr, PageFormat pf) ИЛИ setPageble (Pageable pg). Заодно задаются один или несколько классов рг, рисующих страницы в этом задании.

Остальные параметры задания можно задать в стандартном диалоговом окне Печать (Print) операционной системы, которое открывается на экране при выполнении логического метода printoiaiog (). Указанный метод не имеет аргументов. Он возвратит true, когда пользователь щелкнет по кнопке ОК, и false после нажатия кнопки Отмена.

Остается задать число копий, если оно больше 1, методом setcopies(int n) и задание сформировано.

Еще один полезный метод defaultPage() класса PrinterJob возвращает объект класса PageFormat по умолчанию. Этот метод можно использовать вместо конструктора класса PageFormat.

Осталось сказать, как создается экземпляр класса PrinterJob. Поскольку этот класс тесно связан с системой печати компьютера, его объекты создаются не конструктором, а статическим методом getPrinterJob(), Имеющимся в том же самом классе Printer Job.

Начало печати задается методом print () класса PrinterJob. Этот метод не имеет аргументов. Он.последбватель но вызывает методы print (g, pf, ind) классов, рисующих страницы, для каждой страницы.

Соберем все это вместе в листинге 18.8. В нем средствами JavaJ2D печатается то же, что и в листинге 18.7. Обратите внимание на п.

6.

Пдсле окончания печати программа не заканчивается автоматически, для ее завершения мы обращаемся к методу System.exit (0).



Листинг 18.8.

Простая печать методами Java 2D

import java.awt.*;

import java.awt.geom.*;

import java.awt.print.*;

class Print2Test implements Printable{

public int print(Graphics g, PageFormat pf, int ind)

throws PrinterException{ // Печатаем не более 5 страниц


if (ind > 4) return Printable.NO_SUCH_PAGE;

Graphics2D g2 = (Graphics2D)g;

g2.setFont(new Font("Serif", Font.ITALIC, 30));

g2.setColor (Color.black);

g2.drawstring("Page " + (ind + I), 100, 100);

g2.draw(new Ellipse2D.Double(100, 100, 200, 200));

return Printable.PAGE_EXISTS;

}

public static void main(String[] args){

// 1. Создаем экземпляр задания

PrinterJob pj = Printer Job.getPrinter Job();

// 2, Открываем диалоговое окно Параметры страницы

PageFormat pf = pj.pageDialog (pj.defaultPaige() );

// 3. Задаем вид задания, объект класса, рисующего страницу,

// и выбранные параметры страницы

pj.setPrintable(new Print2Test(), pf};

// 4. Если нужно напечатать несколько копий, то:

pj.setCopies(2); // По умолчанию печатается одна копия

// 5. Открываем диалоговое окно Печать (необязательно)

if (pj.printDialog())( // Если OK... try{

pj.print(); // Обращается к print(g, pf, ind)

}catch(Exception e){

System.err.println(e);

}

}

// 6. Завершаем задание

System.exit(0);

}

}

Печать страниц с разными параметрами

Печать вида Printable Job не совсем удобна — у всех страниц должны быть одинаковые параметры, нельзя задать число страниц и порядок их печати, в окне Параметры страницы не видно число страниц, выводимых на печать.
Все эти возможности предоставляет печать вида Pageable Job с помощью класса Book.
Как уже говорилось выше, сначала создается пустой объект класса
Book
, затем к нему добавляются разные или одинаковые классы, рисующие страницы. При этом определяются объекты класса
pageFormat
, задающие параметры этих страниц, и число страниц. Если число страниц заранее неизвестно, то вместо него указывается константа
UNKNOWN_NUMBER_OF_PAGES
. В таком случае страницы будут печататься в порядке возрастания их номеров до тех пор, пока метод
print
() не возвратит
NO_SUCH_PAGE
.
Метод
setPage(int pagelndex, Printable p, PageFormat pf)
заменяет объект в позиции pagelndex на новый объект р.
В программе листинга 18.10 создаются два класса, рисующие страницы: Cover и content. Эти классы очень просты — в них только реализован метод print(). Класс cover рисует титульный лист крупным полужирным шрифтом. Текст печатается снизу вверх вдоль длинной стороны листа на его правой половине. Класс content выводит обыкновенный текст обычным образом.
Параметры титульного листа определяются в классе pfl, параметры других страниц задаются в диалоговом окне Параметры страницы и содержатся в классе рf2.
В объект bk класса Book занесены три страницы: первая страница — титульный лист, на двух других печатается один и тот же текст, записанный в методе print() класса Content.

Листинг 18.10.
Печать страниц с разными параметрами
import j ava.awt.*;
import j ava.awt.print.*;
public class Print2Book{
public static void main(String[]
args){
PrinterJob pj = PrinterJob.getPrinterJob();
// Для титульного листа выбирается альбомная ориентация
PageFormat pfl = pj.defaultPage();
pfl.setOrientation(PageFormat.LANDSCAPE);

// Параметры других страниц задаются в диалоговом окне

PageFormat pf2 = pj.pageDialog (new PageFormat());

Book bk = new Book();

// Первая страница — титульный лист

bk.append(new Cover(), pfl);

// Две другие страницы

bk.append(new Content(), pf2, 2);

// Определяется вид печати — Pageable Job

pj.setPageable(bk);

if (pj.printDialog()){

try{

pj.print() ;

}catch (Exception e){}

}

System.exit(0);

}

}

class Cover implements Printable{

public int print( Graphics g, PageFormat pf, int ind)

throws PrinterException{

g.setFont (new Font ("Helvetica-Bold", Font.PIiAIsN, 40)) ;

g.setColor(Color.black) ;

int у = (int) (pf.getlmageableY() +

pf.getlmageableHeigbt() /2);

g.drawstring("Это заголовок,", 72, у);

g.drawstring("Он печатается вдоль длинной", 72, у+60);

g.drawstring("стороны листа бумаги.", 72, у+120);

return Printable.PAGE_EXISTS;

}

}

class Content implements Printable{

public int print(Graphics g, PageFormat pf, int ind)

throws PrinterException{

Graphics2D g2 = (Graphics2D)g;

g2.setFont(new Font("Serif", Font.PLAIN, 12));

g2.setColor(Color.black);

int x = (int)pf .getlmageableXO + 30;

int у = (int)pf.getlmageableY();

g2.drawstring("Это строки обычного текста.", х, у += 16);

g2.drawstring("Они печатаются с параметрами,", х, у += 16);

g2.drawstring("выбранными в диалоговом окне.", х, у += 16);

return Printable.PAGE_EXISTS;

}

}

Печать в Java

Поскольку принтер — устройство графическое, вывод на печать очень похож на вывод графических объектов на экран. Поэтому в Java средства печати входят в графическую библиотеку AWT и в систему Java 2D.
В графическом компоненте кроме графического контекста — объекта класса Graphics, создается еще "печатный контекст". Это тоже объект класса Graphics, но реализующий интерфейс printGraphics и полученный из другого источника — объекта класса print job, входящего в пакет java.awt. Сам же этот объект создается с помощью класса Toolkit пакета java.awt. На практике это выглядит так:
PrintJob pj = getToolkitO .get,Print Job (this, "Job Title", null);
Graphics pg = pj.getGraphics();
Метод getPrintJob () сначала выводит на экран стандартное окно Печать (Print) операционной системы. Когда пользователь выберет в этом окне параметры печати и начнет печать кнопкой ОК, создается объект pj. Если пользователь отказывается от печати при помощи кнопки Отмена (Cancel), то метод возвращает null.
В классе
Toolkit
два метода
getPrint Job ():
getPrintJob(Frame frame, String jobTitle, JobAttributes jobAttr,
PageAttributes pageAttr)
getPrintJob(Frame frame, String jobTitle, Properties prop)
Аргумент frame указывает на окно верхнего уровня, управляющее печатью. Этот аргумент не может быть null. Строка jobTitle задает заголовок задания, который не печатается, и может быть равна null. Аргумент prop зависит от реализации системы печати, часто это просто null, в данном случае задаются стандартные параметры печати.
Аргумент jobAttr задает параметры печати. Класс JobAttributes, экземпляром которого является этот аргумент, устроен сложно. В нем пять подклассов, содержащих статические константы — параметры печати, которые используются в конструкторе класса. Впрочем, есть конструктор по умолчанию, задающий стандартные параметры печати.
Аргумент pageAttr задает параметры страницы. Класс pageProperties тоже содержит пять подклассов со статическими константами, которые и задают параметры страницы и используются в конструкторе класса. Если для печати достаточно стандартных параметров, то можно воспользоваться конструктором по умолчанию.

Мы не будем рассматривать эти десять подклассов с десятками констант, чтобы не загромождать книгу мелкими подробностями. К тому же система Java 2D предлагает более удобный набор классов для печати, который мы рассмотрим в следующем пункте.

После того как "печатный контекст" — объект pg класса Graphics — определен, МОЖНО вызывать МеТОД print(pg) ИЛИ printAll(pg) Класса Component. Этот метод устанавливает связь с принтером по умолчанию и вызывает метод paint (pg). На печать выводится все то, что задано этим методом.

Например, чтобы распечатать текстовый файл, надо в процессе ввода разбить его текст на строки и в методе paint (pg) вывести строки методом pg.drawstring() так же, как мы выводили их на экран в

главе 9.

При этом следует учесть, что в "печатном контексте" нет шрифта по умолчанию, всегда надо устанавливать шрифт методом pg.setFont ().

После выполнения всех методов print о применяется метод pg. dispose(), вызывающий прогон страницы, и метод pj .endо, заканчивающий печать.

В листинге 18.7 приведен простой пример печати текста и окружности, заданных в методе paint (>. Этот метод работает два раза: первый раз вычерчивая текст и окружность на экране, второй раз, точно так же, на листе бумаги, вставленной в принтер. Все методы печати собраны в один метод

simplePrint().



Листинг 18.7.

Печать средствами AWT

import java.awt.*;

import j ava.awt.event.*;

class PrintTest extends Frame{

PrintTest(String s){

super(s);

setSize(400, 400);

setVisible(true);

}

public void simplePrint{){

PrintJob pj =

getToolkitO.getPrintJob(this, "JobTitle", null);

if (pj != null){

Graphics pg = pj.getGraphics();

if (pg != null){

print(pg);

pg.dispose();

}else System.err.println("Graphics's null");

pj.end();

}else System.err.println("Job's null");

}

public void paint(Graphics g){

g.setFonttnew Font("Serif", Font.ITALIC, 30));

g.setColor(Color.black);

g.drawArcdOO, 100, 200, 200, 0, 360);

g.drawstring("Страница 1", 100, 100);

}

public static void main(String[] args){

PrintTest pt = new PrintTest(" Простой гфимер печати");

pt.simplePrint();

pt.addWindowListener(new WindowAdpter(){

public void windowClosing(WindowEvent ev){

System.exit(0);

}

});

}

}

Получение свойств файла

В конструкторах классов файлового ввода/вывода, описанных в предыдущем разделе, указывалось имя файла в виде строки. При этом оставалось неизвестным, существует ли файл, разрешен ли к, нему доступ, какова длина файла.
Получить такие сведения можно от предварительно созданного экземпляра класса File, содержащего сведения о файле. В конструкторе этого класса
File(String filename)
указывается путь к файлу или каталогу, записанный по правилам операционной системы. В UNIX имена каталогов разделяются наклонной чертой /, в MS Windows — обратной наклонной чертой \, в Apple Macintosh — двоеточием :. Этот символ содержится в системном свойстве file.separator (см. рис. 6.2). Путь к файлу предваряется префиксом. В UNIX это наклонная черта, в MS Windows — буква раздела диска, двоеточие и обратная наклонная черта. Если префикса нет, то путь считается относительным и к нему прибавляется путь к текущему каталогу, который хранится в системном свойстве user.dir.
Конструктор не проверяет, существует ли файл с таким именем, поэтому после создания объекта следует это проверить логическим методом exists ().
Класс File содержит около сорока методов, позволяющих узнать различные свойства файла или каталога.
Прежде всего, логическими методами isFileO, isDirectoryO можно выяснить, является ли путь, указанный в конструкторе, путем к файлу или каталогу.
Для каталога можно получить его содержимое — список имен файлов и подкаталогов— методом list о, возвращающим массив строк stringf]. Можно получить такой же список в виде массива объектов класса File[] методом listFilest). Можно выбрать из списка только некоторые файлы, реализовав интерфейс FileNameFiiter и обратившись к методу
list(FileNameFilter filter).
Если каталог с указанным в конструкторе путем не существует, его можно создать логическим методом mkdir(). Этот метод возвращает true, если каталог удалось создать. Логический метод mkdirso создает еще и все несуществующие каталоги, указанные в пути.
Пустой каталог удаляется методом delete ().

Для файла можно получить его длину в байтах методом length (), время последней модификации в секундах с 1 января 1970 г. методом lastModifiedo. Если файл не существует, эти методы возвращают нуль.

Логические методы canRead (), canwrite () показывают права доступа к файлу.

Файл можно переименовать логическим методом renameTo(Fiie newMame) или удалить логическим методом delete о. Эти методы возвращают true, если операция прошла удачно.

Если файл с указанным в конструкторе путем не существует, его можно создать логическим методом createNewFilet), возвращающим true, если файл не существовал, и его удалось создать, и false, если файл уже существовал.

Статическими методами

createTempFile(String prefix, String suffix, File tmpDir)

createTempFile(String prefix, String suffix)

можно создать временный файл с именем prefix и расширением suffix в каталоге tmpDir или каталоге, указанном в системном свойстве java.io.tmpdir (см. рис. 6.2). Имя prefix должно содержать не менее трех символов. Если suffix = null, то файл получит суффикс .tmp.

Перечисленные методы возвращают ссылку типа File на созданный файл. Если обратиться к методу deieteOnExit (), то по завершении работы JVM временный файл будет уничтожен.

Несколько методов getxxxo возвращают имя файла, имя каталога и другие сведения о пути к файлу. Эти методы полезны в тех случаях, когда ссылка на объект класса File возвращается другими методами и нужны сведения о файле. Наконец, метод toURL () возвращает путь к файлу в форме URL.

В листинге 18.2 показан пример использования класса File, а на рис. 18.4 — начало вывода этой программы.



Листинг 18.2.

Определение свойств файла и каталога

import java.io.*;

class FileTest{

public static void main(String[] args) throws IOException{

PrintWriter pw = new PrintWriter(

new OutputStreamWriter(System.out, "Cp866"), true);

File f = new File("FileTest.Java");

pw.println();

pw.println("Файл \"" + f.getName() + "\" " +


(f.exists()?"":"не ") + "существует");

pw.println("Вы " + (f.canRead()?"":"не ") + "можете читать файл");

pw.println("Вы " + (f.canWrite()?"":"нe ") +

"можете записывать в файл");

pw.println("Длина файла " + f.length() + " б");

pw.println() ;

File d = new File("

D:\\jdkl.3\\MyProgs

");

pw.println("Содержимое каталога:");

if (d.exists() && d.isDirectory()) {

String[] s = d.list();

for (int i = 0; i < s.length; i++)

pw.println(s[i]);

}

}

}

Рис. 18.4.

Свойства файла и начало вывода каталога

Поток простых типов Java

Класс DataOutputstream позволяет записать данные простых типов Java в выходной поток айтов методами
writeBoolean (boolean b), writeBytefint b), writeShort(int h), writeChar(int c), writelnt"(int n), writeLong(long 1), writeFloat(float f), writeDouble(double d).
Кроме того, метод writeBytes(string s) записывает каждый символ строки s в один байт, отбрасывая старший байт кодировки каждого символа Unicode, а метод writecnarststring s) записывает каждый символ строки s в два байта, первый байт — старший байт кодировки Unicode, так же, как это делает метод writeChar ().
Еще один метод writeUTFtstring s) записывает строку s в выходной поток в кодировке UTF-8. Надо пояснить эту кодировку.

Прямой доступ к файлу

Если необходимо интенсивно работать с файлом, записывая в него данные разных типов Java, изменяя их, отыскивая и читая нужную информацию, то лучше всего воспользоваться методами класса RandomAccessFile.
В конструкторах этого класса
RandomAccessFile(File file, String mode)
RandomAccessFile(String fileName, String mode)
вторым аргументом mode задается режим открытия файла. Это может быть строка "r" — открытие файла только для чтения, или "rw" — открытие файла для чтения и записи.
Этот класс собрал все полезные методы работы с файлом. Он содержит все методы классов Datainputstream и DataOutputstream, кроме того, позволяет прочитать сразу целую строку методом readidne () и отыскать нужные данные в файле.
Байты файла нумеруются, начиная с 0, подобно элементам массива. Файл снабжен неявным указателем (file pointer) текущей позиции. Чтение и запись производится, начиная с текущей позиции файла. При открытии файла конструктором указатель стоит на начале файла, в позиции 0. Текущую позицию можно узнать методом getFiiePointer(). Каждое чтение или запись перемещает указатель на длину прочитанного или записанного данного. Всегда можно переместить указатель в новую позицию, роз методом seek (long pos). Метод seek(0) перемещает указатель на начало файла.
В классе нет методов преобразования символов в байты и обратно по кодовым таблицам, поэтому он не приспособлен для работы с кириллицей.

Сериализация объектов

Методы классов ObjectlnputStream и ObjectOutputStream позволяют прочитать из входного байтового потока или записать в выходной байтовый поток данные сложных типов — объекты, массивы, строки — подобно тому, как методы классов Datainputstream и DataOutputstream читают и записывают данные простых типов.
Сходство усиливается- тем, Что классы Objeetxxx содержат методы как для чтений, так и записи простых типов. Впрочем, эти методы предназначены не для использования в программах, а для записи/чтения полей объектов и элементов массивов.
Процесс записи объекта в выходной поток получил название
сериализации
(serialization), а чтения объекта из входного потока и восстановления его в оперативной памяти —
десериализации
(deserialization).
Сериализация объекта нарушает его безопасность, поскольку зловредный процесс может сериализовать объект в массив, переписать некоторые элементы массива, представляющие private-поля объекта, обеспечив себе, например, доступ к секретному файлу, а затем десериализовать объект с измененными полями и совершить с ним недопустимые действия.
Поэтому сериализации можно подвергнуть не каждый объект, а только тот, который реализует интерфейс seriaiizabie. Этот интерфейс не содержит ни полей, ни методов. Реализовать в нем нечего. По сути дела запись
class A implements Seriaiizabie{...}
это только пометка, разрешающая сериализацию класса А.
Как всегда в Java, процесс сериализации максимально автоматизирован. Достаточно создать объект класса ObjectOutputStream, связав его с выходным потоком, и выводить в этот поток объекты методом writeObject():
MyClass me = new MyClass("abc",
-12,
5.67e-5);
int[] arr = {10, 20, 30};
ObjectOutputStream oos = new ObjectOutputStream(
new FileOutputStream("myobjects.ser")) ;
oos.writeObject(me);
oos.writeObject(arr);
oos.writeObject("Some string");
oos.writeObject (new Date());
oos.flush();
В выходной поток выводятся все нестатические поля объекта, независимо от прав доступа к ним, а также сведения о классе этого объекта, необходимые для его правильного восстановления при десериализации. Байт-коды методов класса не сериализуются.

Если в объекте присутствуют ссылки на другие объекты, то они тоже сериализуются, а в них могут быть ссылки на другие объекты, которые опять-таки сериализуются, и получается целое множество причудливо связанных между собой сериализуемых объектов. Метод writeObjecto распознает две ссылки на один объект и выводит его в выходной поток только один раз. К тому же, он распознает ссылки, замкнутые в кольцо, и избегает зацикливания.

Все классы объектов, входящих в такое сериализуемое множество, а также все их внутренние классы, должны реализовать интерфейс seriaiizabie, в противном случае будет выброшено исключение класса NotseriaiizabieException и процесс сериализации прервется. Многие классы J2SDK реализуют этот интерфейс. Учтите также, что все потомки таких классов наследуют реализацию. Например, класс java.awt.Component реализует интерфейс Serializable, значит, все графические компоненты можно сериализовать. Не реализуют этот интерфейс обычно классы, тесно связанные с выполнением программ, например, java.awt.Toolkit. Состояние экземпляров таких классов нет смысла сохранять или передавать по сети. Не реализуют интерфейс Serializable и классы, содержащие внутренние сведения Java "для служебного пользования".

Десериализация происходит так же просто, как и сериализация:

ObjectlnputStream ois = new ObjectInputStream(

new FilelnputStream("myobjects.ser"));

MyClass mcl = (MyClass)ois.readObject();

int[] a = (int[])ois.readObject();

String s = (String)ois.readObject();

Date d = (Date)ois.readObject() ;

Нужно только соблюдать порядок чтения элементов потока. В листинге 18.6 мы создаем объект класса GregorianCaiendar с текущей датой и временем, сериализуем его в файл date.ser, через три секунды десериа-лизуем и сравниваем с текущим временем. Результат показан на рис. 18.7.



Листинг 18.6.

Сериализация объекта

import java.io.*;

import java.util.*;

class SerDatef

public static void main(String[] args) throws Exception{


GregorianCaiendar d - new GregorianCaiendar();

QbjectOutputStream oos = new ObjectOutputStream{

new FileOutputStream("date.ser"));

oos.writeObject(d);

oos.flush();

oos.close();

Thread.sleep(3000);

ObjectlnputStream ois = new ObjectlnputStream(

new FileInputStream("date.ser"));

GregorianCaiendar oldDate = (GregorianCaiendar)ois.readObject();

ois.close();

GregorianCaiendar newDate = new GregorianCaiendar();

System.out.println("Old time = " +

oldDate.get(Calendar.HOUR) + ":" +

oldDate.get(Calendar.MINUTE) +":" +

oldDate.get(Calendar.SECOND) +"\nNew time = " +

newDate.get(Calendar.HOUR) +":" +

newDate.get(Calendar.MINUTE) +":" +

newDate.get(Calendar.SECOND));

}

}

Рис.18.7.

Сериализация объекта

Если не нужно сериализовать какое- то поле, то достаточно пометить его служебным словом transient, например:

transient MyClass me = new MyClass("abc", -12, 5.67e-5);

Метод writeObjecto не записывает в выходной поток поля, помеченные static и transient. Впрочем, это положение можно изменить, переопределив метод writeObjecto или задав список сериализуемых полей.

Вообще процесс сериализации можно полностью настроить под свои нужды, переопределив методы ввода/вывода и воспользовавшись вспомогательными классами. Можно даже взять весь процесс на себя, реализовав не интерфейс Serializable, а интерфейс Externaiizabie, но тогда придется реали-зовать методы readExternai () и writeExternai о, выполняющие ввод/вывод.

Эти действия выходят за рамки книги. Если вам необходимо полностью освоить процесс сериализации, то обратитесь к спецификации Java Object Serialization Specification, расположенной среди документации J2SDK в каталоге docs\guide\serialization\spec\. Там же есть и примеры программ, реализующих эту спецификацию.

Иллюстрированный самоучитель по Java

Работа по протоколу TCP

Программы-серверы, прослушивающие свои порты, работают под управлением операционной системы. У машин-серверов могут быть самые разные операционные системы, особенности которых передаются программам-серверам.
Чтобы сгладить различия в реализациях разных серверов, между сервером и портом введен промежуточный программный слой, названный
сокетом
(socket). Английское слово socket переводится как электрический разъем, розетка. Так же как к розетке при помощи вилки можно подключить любой электрический прибор, лишь бы он был рассчитан на 220 В и 50 Гц, к соке-ту можно присоединить любой клиент, лишь бы он работал по тому же протоколу, что и сервер. Каждый сокет связан (bind) с одним портом, говорят, что сокет прослушивает (listen) порт. Соединение с помощью сокетов устанавливается так.
1. Сервер создает сокет, прослушивающий порт сервера.
2. Клиент тоже создает сокет, через который связывается с сервером, сервер начинает устанавливать (accept) связь с клиентом.
3. Устанавливая связь, сервер создает новый сокет, прослушивающий порт с другим, новым номером, и сообщает этот номер клиенту.
4. Клиент посылает запрос на сервер через порт с новым номером.
После этого соединение становится совершенно симметричным — два сокета обмениваются информацией, а сервер через старый сокет продолжает прослушивать прежний порт, ожидая следующего клиента.
В Java сокет — это объект класса socket из пакета java.io. В классе шесть конструкторов, в которые разными способами заносится адрес хоста и номер порта. Чаще всего применяется конструктор
Socket(String host, int port)
Многочисленные методы доступа устанавливают и получают параметры со-кета. Мы не будем углубляться в их изучение. Нам понадобятся только методы, создающие потоки ввода/вывода:
getlnputStream()
— возвращает входной поток типа InputStream;
getOutputStream()
— возвращает выходной поток типа OutputStream.
Приведем пример получения файла с сервера по максимально упрощенному протоколу HTTP.

1. Клиент посылает серверу запрос на получение файла строкой "POST filename HTTP/1.l\n\n", где filename — строка с путем к файлу на сервере.

2. Сервер анализирует строку, отыскивает файл с именем filename и возвращает его клиенту. Если имя файла filename заканчивается наклонной чертой /, то сервер понимает его как имя каталога и возвращает файл in-dex.html, находящийся в этом каталоге.

3. Перед содержимым файла сервер посылает строку вида "HTTP/1.1 code OK\n\n", где code — это код ответа, одно из чисел: 200 — запрос удовлетворен, файл посылается; 400 — запрос не понят; 404 — файл не найден.

4. Сервер закрывает сокет и продолжает слушать порт, ожидая следующего запроса.

5. Клиент выводит содержимое полученного файла в стандартный вывод System, out или выводит код сообщения сервера в стандартный вывод сообщений System, err.

6. Клиент закрывает сокет, завершая связь.

Этот протокол реализуется в клиентской программе листинга 19.3 и серверной программе листинга 19.4.



Листинг 19.3.

Упрощенный HTTP-клиент

import java.net.*;

import java.io.*;

import java.util.*;

class Client{

public static void main(String[] args){

if (args.length != 3){

System.err.println("Usage: Client host port file");

System.exit(0) ;

}

String host = args[0];

int port = Integer.parselnt(args[1]);

String file = args[2];

try{

Socket sock = new Socket(host, port);

PrintWriter pw = new PrintWriter(new OutputStreamWriter(

sock.getOutputStreamf)), true);

pw.println("POST " + file + " HTTP/1.l\n");

BufferedReader br = new BufferedReader(new InputStreamReader(

sock.getlnputStream() ) ) ;

String line = null;

line = br.readLine();

StringTokenizer st = new StringTokenizer(line);

String code = null;

if ((st.countTokens() >= 2) && st.nextToken().equals("POST")){

if ((code = st.nextToken()) != "200") {


System.err.println("File not found, code = " + code);

System.exit (0);

}

}

while ((line = br.readLine()) != null)

System.out.println{line);

sock.close();

}catch(Exception e){

System.err.println(e);

}

}

}

Закрытие потоков ввода/ вывода вызывает закрытие сокета. Обратно, закрытие сокета закрывает и потоки.

Для создания сервера в пакете java.net есть класс serversocket. В конструкторе этого класса указывается номер порта

ServerSocket(int port)

Основной метод этого класса accept () ожидает поступления запроса. Когда запрос получен, метод устанавливает соединение с клиентом и возвращает объект класса socket, через который сервер будет обмениваться информацией с клиентом.



Листинг 19.4.

Упрощенный HTTP-сервер

import j ava.net.*;

import java.io.*;

import j ava.uti1.*;

class Server!

public static void main(String[] args){

try{

ServerSocket ss = new ServerSocket(Integer.parselnt(args[0]));

while (true)

new HttpConnect(ss.accept());

}catch(ArraylndexOutOfBoundsException ae){

System.err.println("Usage: Server port");

System.exit(0);

}catch(IOException e){

System.out.println(e);

}

}

}

class HttpConnect extends Thread{

private Socket sock;

HttpConnect(Socket s) {

sock = s;

setPriority(NORM_PRIORITY - 1);

start {) ;

}

public void run(){

try{

PrintWriter pw = new PrintWriter(new OutputStreamWriter(

sock.getOutputStream()}, true);

BufferedReader br = new BufferedReader(new InputStreamReader(

sock.getlnputStream() ) ) ;

String req = br.readLine();

System.out.println("Request: " + req);

StringTokenizer st = new StringTokenizer(req);

if ((st.countTokens() >= 2) && st.nextToken().equals("POST")){

if ((req = st.nextToken()).endsWith("/") II req.equals(""))


req += "index.html";

try{

File f = new File(req);

BufferedReader bfr =

new BufferedReader(new FileReader(f));

char[] data = new char[(int)f.length()];

bfr.read(data);

pw.println("HTTP/1.1 200 OK\n");

pw.write(data);

pw.flush();

}catch(FileNotFoundException fe){

pw.println("HTTP/1.1 404 Not FoundXn");

}catch(lOException ioe){

System.out.println(ioe);

}

}else pw.println("HTTP/l.l 400 Bad RequestW);

sock.close();

}catch(IOException e){

System.out.println(e);

}

}

}

Вначале следует запустить сервер, указав номер порта, например:

Java Server 8080

Затем надо запустить клиент, указав IP-адрес или доменное имя хоста, номер порта и имя файла:

Java Client localhost 8080 Server.Java

Сервер отыскивает файл Server.java в своем текущем каталоге и посылает его клиенту. Клиент выводит содержимое этого класса в стандартный вывод и завершает работу. Сервер продолжает работать, ожидая следующего запроса.





Замечание по отладке



Программы, реализующие стек протоколов TCP/IP, всегда создают так называемую "петлю" с адресом 127.0.0.1 и доменным именем localhost. Это адрес самого компьютера. Он используется для отладки приложений клиент-сервер. Вы можете запускать клиент и сервер на одной машине, пользуясь этим адресом.

Работа по протоколу UDP

Для посылки дейтаграмм отправитель и получатель создают сокеты дейта-граммного типа. В Java их представляет класс DatagramSocket. В классе три конструктора:
DatagramSocket ()
— создаваемый сокет присоединяется к любому свободному порту на локальной машине;
DatagramSocket (int port)
— создаваемый сокет присоединяется к порту port на локальной машине;
DatagramSocket(int port, InetAddress addr) — создаваемый СОКСТ при
соединяется к порту port; аргумент addr — один из адресов локальной машины.
Класс содержит массу методов доступа к параметрам сокета и, кроме того, методы отправки и приема дейтаграмм:
send(DatagramPacket pack)
— отправляет дейтаграмму, упакованную в пакет pack;
receive (DatagramPacket pack)
— дожидается получения дейтаграммы и заносит ее в пакет pack.
При обмене дейтаграммами соединение обычно не устанавливается, дейтаграммы посылаются наудачу, в расчете на то, что получатель ожидает их. Но можно установить соединение методом
connect(InetAddress addr, int port)
При этом устанавливается только одностороннее соединение с хостом по адресу addr и номером порта port — или на отправку или на прием дейтаграмм. Потом соединение можно разорвать методом
disconnect()
При посылке дейтаграммы по протоколу JJDP сначала создается сообщение в виде массива байтов, например,
String mes = "This is the sending message.";
byte[] data = mes.getBytes();
Потом записывается адрес — объект класса inetAddress, например:
InetAddress addr = InetAddress.getByName (host);
Затем сообщение упаковывается в пакет — объект класса DatagramPacket. При этом указывается массив данных, его длина, адрес и номер порта:
DatagramPacket pack = new DatagramPacket(data, data.length, addr, port)
Далее создается дейтаграммный сокет
DatagramSocket ds = new DatagramSocket()
и дейтаграмма отправляется
ds.send(pack)
После посылки всех дейтаграмм сокет закрывается, не дожидаясь какой-либо реакции со стороны получателя:

ds.close ()

Прием и распаковка дейтаграмм производится в обратном порядке, вместо метода send () применяется метод receive (DatagramPacket pack).

В листинге 19.5 показан пример класса Sender, посылающего сообщения, набираемые в командной строке, на localhost, порт номер 1050. Класс Recipient, описанный в листинге 19.6, принимает эти сообщения и выводит их в свой стандартный вывод.



Листинг 19.5.

Посылка дейтаграмм по протоколу UDP

import java.net.*;

import java.io.*;

class Sender{

private String host;

private int port;

Sender(String host, int port){

this.host = host;

this.port = port;

}

private void sendMessage(String mes){

try{

byte[] data = mes.getBytes();

InetAddress addr = InetAddress.getByName(host);

DatagramPacket pack =

new DatagramPacket(data, data.length, addr, port);

DatagramSocket ds = new DatagramSocket();

ds.send(pack);

ds.close();

}catch(IOException e){

System.err.println(e);

}

}

public static void main(String[] args){

Sender sndr = new Sender("localhost", 1050);

for (int k = 0; k < args.length; k++)

sndr.sendMessage(args[k]);

}

}



Листинг 19.6.

Прием дейтаграмм по протоколу UDP

import j ava.net.*;

import java.io.*;

class Recipient{

public static void main(String[] args)(

try{

DatagramSocket ds = new DatagramSocket(1050);

while (true){

DatagramPacket pack =

new DatagramPacket(new byte[1024], 1024);

ds.receive(pack);

System.out.println(new String(pack.getData()));

}

)catch(Exception e){

System.out.println(e);

}

}

}

Работа в WWW

Среди программного обеспечения Internet большое распространение получила информационная система WWW (World Wide Web), основанная на прикладном протоколе HTTP (Hypertext Transfer Protocol). В ней используется расширенная адресация, называемая URL (Uniform Resource Locator). Эта адресация имеет такие схемы:

protocol://authority@host:port/path/file#ref

protocol://authority@host:port/path/file/extra_path?info
Здесь необязательная часть authority — это пара имя:пароль для доступа к хосту, host — это IP-адрес или доменное имя хоста. Например:

http://www.bhv.ru/


http://132.192.5.10:8080/public/some.html


ftp://guest:password@lenta.ru/users/local/pub

ffle:///C:/text/html/index.htm
Если какой-то элемент URL отсутствует, то берется стандартное значение. Например, в первом примере номер порта port равен 80, а имя файла path — какой-то головной файл, определяемый хостом, чаще всего это файл с именем index.html. В третьем примере номер порта равен 21. В последнем примере в форме URL просто записано имя файла index.htm, расположенного на разделе С: жесткого диска той же самой машины.
В Java для работы с URL есть класс URL пакета java.net. Объект этого класса создается одним из шести конструкторов. В основном конструкторе
URL(String url)
задается расширенный адрес url в виде строки. Кроме методов доступа getxxxo, позволяющих получить элементы URL, в этом классе есть два интересных метода:
openConnection ()
— определяет связь с URL и возвращает объект класса
URLConnection;
openStream()
— устанавливает связь с URL и открывает входной поток в виде возвращаемого объекта класса inputstream.
Листинг 19.1 показывает, как легко можно получить файл из Internet, пользуясь методом openStream().

Листинг 19.1.
Получение Web-страницы
import java.net.*;
import j ava.io.*;
class SimpleURL{
public static void main(String[] args){
try{
URL bhv = new URL("
http://www.bhv.ru/
");

BufferedReader br = new BufferedReader(

new InputStreamReader(bhv.openStream()));

String line;

while ((line = br.readLine()) != null)

System.out.println(line);

br.close();

}catch(MalformedURLException me){

System.err.println("Unknown host: " + me);

System.exit(0);

}catch(IOException ioe){

System.err.println("Input error: " + ioe);

}

}

}

Если вам надо не только получить информацию с хоста, но и узнать ее тип: текст, гипертекст, архивный файл, изображение, звук, или выяснить длину файла, или передать информацию на хост, то необходимо сначала методом openConnection () создать объект класса URLConnection или его подкласса

HttpURLConnection.

После создания объекта соединение еще не установлено, и можно задать параметры связи. Это делается следующими методами:

setDoOutput (boolean out)

— если аргумент out равен true, то передача пойдет от клиента на хост; значение по умолчанию false;

setDoinput (boolean in)

— если аргумент in равен true, то передача пойдет с хоста к клиенту; значение по умолчанию true, но если уже выполнено setDoOutput(true), то значение по умолчанию равно false;

setUseCaches (boolean cache)

— если аргумент cache равен false, то передача пойдет без кэширования, если true, то принимается режим по умолчанию;

setDefaultUseCaches(boolean default)

— если аргумент default равен true, то принимается режим кэширования, предусмотренный протоколом;

setRequestProperty(String name, String value) —

добавляет параметр name со значением value к заголовку посылаемого сообщения.

После задания параметров нужно установить соединение методом connect (). После соединения задание параметров уже невозможно. Следует учесть, что некоторые методы доступа getxxxo, которым надо получить свои значения с хоста, автоматически устанавливают соединение, и обращение к методу connect () становится излишним.

Web-сервер возвращает информацию, запрошенную клиентом, вместе с заголовком, сведения из которого можно получить методами getxxxo, например:


getcontentType ()

— возвращает строку типа string, показывающую тип пересланной информации, например, "text/html", или null, если сервер его не указал;

getcontentLength ()

— возвращает длину полученной информации в байтах или — 1, если сервер ее не указал;

getcontent ()

— возвращает полученную информацию в виде объекта типа Object;

getContentEncoding ()

— возвращает строку типа string с кодировкой полученной информации, или null, если сервер ее не указал.

Два метода возвращают потоки ввода/вывода, созданные для данного соединения:

getlnputStream()

— возвращает входной поток типа InputStream;

getOutputStream()

— возвращает выходной поток типа OutputStream.

Прочие методы, а их около двадцати, возвращают различные параметры соединения.

Обращение к методу bhv.openstreamo, записанное в листинге 19.1, — это, на самом деле, сокращение записи

bhv.openConnection().getlnputStream()

В листинге 19.2 показано, как переслать строку текста по адресу URL.

Web-сервер, который получает эту строку, не знает, что делать с полученной информацией. Занести ее в файл? Но с каким именем, и есть ли у него право создавать файлы? Переслать на другую машину? Но куда?

Выход был найден в системе CGI (Common Gateway Interface), которая вкратце действует следующим образом. При посылке сообщения мы указываем URL исполнимого файла некоторой программы, размещенной на машине-сервере. Получив сообщение, Web-сервер запускает эту программу и передает сообщение на ее стандартный ввод. Вот программа-то и знает, что делать с полученным сообщением. Она обрабатывает сообщение и выводит результат обработки на свой стандартный вывод. Web-сервер подключается к стандартному выводу, принимает результат и отправляет его обратно клиенту.

CGI-программу можно написать на любом языке: С, C++, Pascal, Perl, PHP, лишь бы у нее был стандартный ввод и стандартный вывод. Можно написать ее и на Java, но в технологии Java есть более изящное решение этой задачи с помощью сервлетов (servlets). CGI-программы обычно лежат на сервере в каталоге cgi-bin.




Листинг 19.2.

Посылка строки по адресу URL

import java.net.*;

import java.io.*;

class PostURL{

public static void main(String[] args){

String req = " This text is posting to URL";

try{

// Указываем URL нужной CGI-программы

URL url = new URL("

http://www.bhv.ru/cgi-bin/some.pl

");

// Создаем объект uc

URLConnection uc = url.openConnection();

// Собираемся отправлять

uc.setDoOutput(true);

// и получать сообщения

uc.setDoInput(true);

// без кэширования

uc.setUseCaches(false);

// Задаем тип

uc.setRequestProperty("content-type",

"application/octet-stream");

// и длину сообщения

uc.setRequestProperty("content-length", "" + req.length());

// Устанавливаем соединение

uc.connect();

// Открываем выходной поток

DataOutputStream dos = new DataOutputStream( uc.getOutputStreamO);

// и выводим в него сообщение, посылая его на адрес

URL dos.writeBytes(req);

// Закрываем выходной поток

dos.close();

// Открываем входной поток для ответа сервера

BufferedReader br = new BufferedReader(new InputStreamReader(

uc.getlnputStream() )) ;

String res = null;

// Читаем ответ сервера и выводим его на консоль

while ((res = br.readLine()) != null)

System.out.println(res);

br.close () ;

}catch(MalformedURLException me){

System.err.println(me);

}catch(UnknownHostException he){

System.err.println(he);

}catch(UnknownServiceException se){

System.err.println(se);

}catch(IOException ioe){

System.err.println(ioe);

}

}

}

Иллюстрированный самоучитель по Java

Архиватор jar

Для упаковки нескольких файлов в один архивный файл, со сжатием или без сжатия., в технологии Java разработан формат JAR. Имя архивного jar-файла может быть любым, но обычно оно получает расширение jar. Способ упаковки и сжатия основан на методе ZIP. Название JAR (Java ARchive) перекликается с названием известной утилиты TAR (Tape ARchive), разработанной в UNIX.
Отличие jar-файлов от zip-файлов только в том, что в первые автоматически включается каталог META-INF, содержащий несколько файлов с информацией об упакованных в архив файлах.
Архивные файлы очень удобно использовать в апплетах, поскольку весь архив загружается по сети сразу же, одним запросом. Все файлы апплета с байт-кодами, изображениями, звуковые файлы упаковываются в один или несколько архивов. Для их загрузки достаточно в теге указать имена архивов в параметре archive, например:
width = "100%" height = "100%">
Основной файл MillAnim.class должен находиться в каком-либо из архивных файлов first.jar или second.jar. Остальные файлы отыскиваются в архивных файлах, а если не найдены там, то на сервере, в том же каталоге, что и HTML-файл. Впрочем, файлы апплета можно упаковать и в zip-архив, со сжатием или без сжатия.
Архивные файлы удобно использовать и в приложениях (applications). Все файлы приложения упаковываются в архив, например, appl.jar. Приложение выполняется прямо из архива, интерпретатор запускается с параметром -jar, например:
Java -jar appl.jar
Имя основного класса приложения, содержащего метод main (), указывается в файле MANIFEST.MF, речь о котором пойдет чуть ниже.
Архивные файлы удобны и просты для компактного хранения всей необходимой для работы программы информации. С файлами архива можно работать прямо из архива, не распаковывая их, с помощью классов пакета
java.util.jar.

Файл INDEX.LIST

Для ускорения поиска файлов и более быстрой их загрузки можно создать файл поиска INDEX.LIST. Это делается после создания архива. Утилита jar запускается еще раз с параметром
-i,
например:
jar -i Base.jar
После этого в каталоге META-INF архива появляется файл INDEX.LIST. На рис. П.З представлено, как создается файл поиска и как выглядит содержимое архива после его создания.

Рис. П.3.
Создание файла поиска

Файл описания MANIFEST.MF

Файл MANIFEST.MF, расположенный в каталоге META-INF архивного файла, предназначен для нескольких целей:
перечисления файлов из архива, снабженных цифровой подписью;
перечисления компонентов JavaBeans, расположенных в архиве;
указания имени основного класса для выполнения-приложения из архива;
записи сведений о версии пакета.
Вся информация сначала записывается в обычном текстовом файле с любым именем, например, manif. Потом запускается утилита jar, в которой этот файл указывается как значение параметра т, например:
jar cmf manif Base.jar classes Base.class
Утилита проверяет правильность записей в файле manif и переносит их в файл MANIFEST.MF, добавляя свои записи.
Файл описания manif должен быть написан по строгим правилам, изложенным в спецификации JAR File Specification. Ее можно найти в документации Java 2 SDK, в файле docs\guide\jar\jar.html.
Например, если мы хотим выполнять приложение с главным файлом Base.class из архива Base.jar, то файл manif должен содержать как минимум две строки:
Main-Class: Base
Первая строка содержит относительный путь к главному классу, но не к файлу, т. е. без расширения class. В этой строке каждый символ имеет значение, даже пробел. Вторая строка пустая — файл обязательно должен заканчиваться пустой строкой, точнее говоря, символом перевода строки '\n'.
После того как создан архив Base.jar, можно выполнять приложение прямо из него:
Java -jar Base.jar

Java на сервере

Тенденция написания сетевых программ — побольше функций возложить на серверную часть программы и поменьше оставить клиентской части, сделав клиент "тонким", а сервер "толстым". Это позволяет, с одной стороны, использовать клиентскую часть программы на самых старых и маломощных компьютерах, а с другой стороны, облегчает модификацию программы — все изменения достаточно сделать только в одном месте, на сервере.
Сервер выполняет все больше функций, как говорят,
служб
или
сервисов
(services). Он и отправляет клиенту Web-страницы, и выполняет сервлеты, и связывается с базой данных, и обеспечивает транзакции. Такой многофункциональный сервер называется
сервером приложений
(application server). Большой популярностью сейчас пользуются серверы приложений WebLogic фирмы ВЕА Systems, IAS (Inprise Application Server) фирмы Borland, WebSphere фирмы IBM, OAS (Oracle Application Server). Важной характеристикой сервера приложений является способность расширять свои возможности путем включения новых модулей. Это удобно делать с помощью компонентов.
Фирма SUN Microsystems предложила свою систему компонентов EJB (Enterprise JavaBeans), включенную в Java 2 SDK Enterprise Edition. Подобно тому, как графические компоненты JavaBeans реализуют графический интерфейс пользователя, размещаясь в графических контейнерах, компоненты EJB реализуют различные службы на сервере, располагаясь в EJB-контейнерах. Этими контейнерами управляет EJB-сервер, включаемый в состав сервера приложений. В составе J2SDKEE EJB-сервер — это программа j2ee. Серверу приложений достаточно запустить эту программу, чтобы использовать компоненты EJB.
В отличие от JavaBeans у компонентов EJB не может быть графического интерфейса и ввода с клавиатуры. У них может отсутствовать даже консольный вывод. Контейнер EJB занимается не размещением компонентов, а созданием и удалением их объектов, связью с клиентами и другими компонентами, проверкой прав доступа и обеспечением транзакций.
Программы, оформляемые как EJB, могут быть двух типов: EntityBean и sessionBean. Они реализуют соответствующие интерфейсы из пакета javax.ejb. Первый тип EJB-компонентов удобен для создания программ, обращающихся к базам данных и выполняющих сложную обработку полученной информации. Компоненты этого типа могут работать сразу с несколькими клиентами. Второй тип EJB-компонентов более удобен для организации взаимодействия с клиентом. Компоненты этого типа бывают двух видов: сохраняющие свое состояние от запроса к запросу (stateful) и теряющие это состояние (stateless). Методами интерфейсов EntityBean и SessionBean контейнер EJB управляет поведением экземпляров класса. Если достаточно стандартного управления, то можно сделать пустую реализацию этих методов.

Кроме класса, реализующего интерфейс EntityBean или SessionBean, для создания компонента EJB необходимо создать еще два интерфейса, расширяющие интерфейсы вовноте и EjBObject. Первый интерфейс (home interface) служит для создания объекта EJB своими методами create (), для поиска и связи с этим объектом в процессе работы, и удаления его методом remove о. Второй интерфейс (remote interface) описывает методы компонента EJB. Интересная особенность технологии EJB — клиентская программа не образует объекты компонента EJB. Вместо этого она создает объекты home-и remote-интерфейсов и работает с этими объектами. Реализация home- и remote-интерфейсов, создание объектов компонента EJB и взаимодействие с ними остается на долю контейнера EJB.

Приведем простейший пример. Пусть мы решили обработать выборку из базы данных, занесенную в объект rs в сервлете листинга П.З, с помощью компонента EJB. Для простоты пусть обработка заключается в слиянии двух столбцов методом merge (). Напишем программу:

import java.rmi.RemoteException;

import javax.ejb.*;

public class MergeBean implements SessionBean{

public String merge(String si, String s2){

String s = si + " " + s2;

return s;

}

// Выполняется при обращении к методу create()

// интерфейса MergeHome. Играет роль конструктора класса

public void ejbCreate() {}

// Пустая реализация методов интерфейса

public void setSessionContext(SessionContext ctx){}

public void ejbRemoveO {}

public void ejbActivate()(}

public void ejbPassivate(){} }

public interface MergeHome extends EJBHome{

// Реализуется методом ejbCreate() класса MergeBean

Merge create)} throws CreateException, RemoteException;

}

public interface Merge extends EJBObject{

public double merge(String si, String s2)

throws RemoteException;

}

В сервлете листинга П.3 создаем объекты типа MergeHome и Merge и обращаемся к их методам:

Компоненты JavaBeans

Многие программисты предпочитают разрабатывать приложения с графическим интерфейсом пользователя с помощью визуальных средств разработки: JBuilder, Visual Age for Java, Visual Cafe и др. Эти средства позволяют помещать компоненты в контейнер графически, с помощью мыши. На рис. П.4 показано окно JBuilder 4.
Левый нижний угол окна занимает форма, на которой размещаются компоненты. Сами компоненты показаны ярлыками на панели компонентов, расположенной выше формы. На рис. П.4 на панели компонентов виден ярлык компонента Button, показанный прямоугольником с надписью ОК, ярлык компонента checkbox, показанный квадратиком с крестиком, ярлык компонента checkboxGroup, обозначенный группой радиокнопок. Далее видны ярлыки компонентов choice, Label, List и другие компоненты AWT.
Чтобы поместить компонент в форму, надо щелкнуть кнопкой мыши на ярлыке компонента, перенести курсор мыши в нужное место формы и щелкнуть кнопкой мыши еще раз.
Затем с помощью мыши необходимо установить нужные размеры компонента. При этом можно передвинуть компонент на другое место. На рис. П.4 в форму помещена кнопка типа Button.

Рис. П.4.
Окно JBuilder 4
Далее следует определить свойства (properties) компонента: текст, цвет текста и фона, вид курсора мыши, когда он появляется над компонентом Свойства определяются в окне свойств, расположенном справа от формы В левой колонке окна перечислены имена свойств, в правую колонку надо записать их значения. На рис. П.4 свойству label — надписи на кнопке — дано значение Выполнить. Это значение тут же появляется на кнопке
Потом можно задать обработку событий, открыв вторую страницу окна свойств.
Для того чтобы компонент можно было применять в таком визуальном средстве разработки как JBuilder, он должен обладать дополнительными качествами. У него должен быть ярлык, помещаемый на панель компонентов. Среди полей компонента должны быть выделены свойства (properties), которые будут показаны в окне свойств Следует определить методы доступа
getXxx () /setXxx () /isXxx ()

к каждому свойству

Компонент, снабженный этими и другими необходимыми качествами, в технологии Java называется компонентом JavaBean. В него может входить один или несколько классов. Как правило, файлы этих классов упаковываются в jar-архив и отмечаются в файле MANIFEST.MF как Java-Bean: True.

Все компоненты AWT и Swing являются компонентами JavaBeans. Если вы создаете свой графический компонент по правилам, изложенным в

части 3,

то вы тоже получаете свой JavaBean. Но для того чтобы не упустить каких-либо важных качеств JavaBean, лучше использовать для их разработки специальные средства.

Фирма SUN поставляет набор необходимых утилит и классов BDK (Beans Development Kit) для разработки JavaBeans. Так же, как и SDK, этот набор хранится на сайте фирмы в виде самораспаковывающегося архива, например, bdkl_l-win.exe. Его содержимое распаковывается в один каталог, например, D:\bdkl.l. После перехода в каталог bdkl.l\beanbox\ и запуска файла run.bat (или run.sh в UNIX) открываются несколько окон утилиты Bean-Box, работа с которой ведется по тому же принципу, что и в визуальных средствах разработки.

Правила оформления компонентов JavaBeans изложены в спецификации JavaBeans API Specification, которую можно найти по адресу http://

java.sun.com/products/javabeans/docs/spec.html.

Визуальные средства разработки — это не основное применение JavaBeans. Главное достоинство компонентов, оформленных как JavaBeans, в том, что они без труда встраиваются в любое приложение. Более того, приложение можно собрать из готовых JavaBeans как из строительных блоков, остается только настроить их свойства.

Специалисты пророчат большое будущее компонентному программированию. Они считают, что скоро будут созданы тысячи компонентов JavaBeans на все случаи жизни и программирование сведется к поиску в Internet нужных компонентов и сборке из них приложения.

Переход к Swing

В
части 3
мы подробно рассмотрели возможности графической библиотеки AWT. Там же мы заметили, что в состав Java 2 SDK входит еще одна графическая библиотека, Swing, с более широкими возможностями, чем AWT. Фирма SUN настоятельно рекомендует использовать Swing, а не AWT, но, во-первых, Swing требует больше ресурсов, что существенно для российского разработчика, во-вторых, большинство браузеров не имеет в своем составе Swing. В-третьих, удобнее сначала познакомиться с библиотекой AWT, а уже потом изучать Swing.
Все примеры графических программ, приведенные в книге, будут выполняться методами библиотеки Swing после небольшой переделки:
1. Добавьте в заголовок строку import javax.swing.*;.
2. Поменяйте Frame на JFrame, Applet на JApplet, Component нa JComponent, Panel на JPanei. He расширяйте свои классы от класса canvas, используйте jpanei или другие контейнеры Swing.
3. Замените компоненты AWT на близкие к ним компоненты Swing. Чаще всего надо просто приписать букву j: JButton, JcheckBox, JDialog, jList, JMenu и т. д. Закомментируйте временно строку import java.awt.*; и попробуйте откомпилировать программу. Компилятор покажет, какие компоненты требуют замены.
4. Включите в конструктор класса, расширяющего JFrame, строку Container с = getContentPane (); и располагайте все компоненты в контейнере с, Т. е. пишите c.add(), с.setLayout ().
5. Класс jFrame содержит средства закрытия своего окна, надо только настроить их. Вы можете убрать addwindowListener(...) и включить в конструктор обращение К методу setDefaultCloseQperation(JFrame.EXITJB_CLOSE).
6. В прямых подклассах класса jpanei замените метод paint о на paintcomponent () и удалите метод update о. Класс jpanei автоматически производит двойную буферизацию и надобности в методе update о больше нет. Уберите весь код двойной буферизации. В начало метода paintcomponent () включите обращение super.paintcomponent (g). Из подклассов классов JFrame, joialog, JAppiet метод paintcomponent () надо переместить в другие компоненты, например, JButton, JLabel, jpanei.

7. Используйте вместо класса image класс imageicon. Конструкторы этого класса выполнят необходимое преобразование. Класс imageicon автоматически применяет методы класса MediaTracker для ожидания окончания загрузки.

8. При создании апплетов расширением класса JAppiet не забывайте, что в классе Applet менеджером размещения по умолчанию служит класс FiowLayout, а в классе JAppiet менеджер размещения по умолчанию

BorderLayout.

Пункты 4 и 6 требуют пояснения. Окно верхнего уровня в Swing, такое как JFrame, содержит

корневую панель

(root pane), на которой размещена

слоеная панель

(layered pane). Компоненты на слоеной панели можно размещать несколькими слоями, перекрывая друг друга. В одном из слоев находится

панель содержимого

(content pane) и

строка меню

(menu bar). Поверх самого верхнего слоя расположена

прозрачная панель

(glass pane). Поэтому нельзя просто поместить компонент в окно верхнего уровня. Его надо "положить" на какую-нибудь панель. Пункт 4 рекомендует размещать компоненты на панели содержимого.

Откомпилировав и запустив измененную программу, вы увидите, что ее внешний вид изменился, чаще всего не в лучшую сторону. Теперь надо настроить компоненты Swing. Библиотека Swing предоставляет для этого широчайшие возможности.

Сервлеты

В
главе 19
была упомянута технология CGI. Ее суть в том, что сетевой клиент, обычно браузер, посылает Web-серверу информацию вместе с указанием программы, которая будет обрабатывать эту информацию. Web-сервер, получив информацию, запускает программу, передает информацию на ее стандартный ввод и ждет окончания обработки. Результаты обработки программа отправляет на свой стандартный вывод, Web-сервер забирает их оттуда и отправляет клиенту. Написать программу можно на любом языке, лишь бы Web-сервер мог взаимодействовать с ней.
В технологии Java такие программы оформляются как
сервлеты
(servlets). Это название не случайно похоже на название "апплеты". Сервлет на Web-сервере играет такую же роль, что и апплет в браузере, расширяя его возможности.
Чтобы Web-сервер мог выполнять сервлеты, в его состав должна входить JVM и средства связи с сервлетами. Обычно все это поставляется в виде отдельного модуля, встраиваемого в Web-сервер. Существует много таких модулей: Resin, Tomcat, JRun, JServ. Они называются на жаргоне
сервлетными движками
(servlet engine).
Основные интерфейсы и классы, описывающие сервлеты, собраны в пакет javax.servlet. Расширения этих интерфейсов и классов, использующие конкретные особенности протокола HTTP, собраны в пакет javax.servlet.http. Еще два пакета— javax.servlet.jsp и javax.servlet.jsp.tagext — предназначены для связи сервлетов со скриптовым языком JSP (JavaServer Pages). Все эти пакеты входят в состав J2SDK Enterprise Edition. Они могут поставляться и отдельно как набор JSDK (Java Servlet Development Kit). Сервлет-ный движок должен реализовать эти интерфейсы.
Основу пакета javax.servlet составляет интерфейс servlet, частично реализованный в абстрактном классе GenericServiet и его абстрактном подклассе HttpServiet. Основу этого интерфейса составляют три метода:
init (Servietconfig config)
— задает начальные значения сервлету, играет ту же роль, что и метод init () в апплетах;
service(ServletRequest req, ServletResponse resp)

— выполняет обработку поступившей сервлету информации req и формирует ответ resp;

destroy ()

— завершает работу сервлета.

Опытный читатель уже понял, что вся работа сервлета сосредоточена в методе service о. Действительно, это единственный метод, не реализованный в классе GenericServiet. Достаточно расширить свой класс от класса . GenericServiet и реализовать в нем метод service (), чтобы получить собственный сервлет. Сервлетный движок, встроенный в Web-сервер, реализует интерфейсы ServletRequest и ServletResponse. Он Создает объекты req и resp, заносит всю поступившую информацию в объект req и передает этот объект сервлету вместе с пустым объектом resp. Сервлет принимает эти объекты как аргументы req и resp метода service о, обрабатывает информацию, заключенную в req, и оформляет ответ, заполняя объект resp. Движок забирает этот ответ и через Web-сервер отправляет его клиенту.

Основная информация, заключенная в объекте req, может быть получена методами read() и readLine() ИЗ байтового потока класса ServletlnputStream, непосредственно расширяющего класс inputstream, или из символьного потока класса BufferedReader. Эти потоки открываются, соответственно, методом req.getlnputStream() или методом req.getReader (). Дополнительные характеристики запроса можно получить многочисленными методами getxxxo объекта req. Кроме того, класс GenericServlet реализует массу методов getxxxo, позволяющих получить дополнительную информацию о конфигурации клиента.

Интерфейс servietResponse описывает симметричные методы для формирования ответа. Метод getoutputstreamo открывает байтовый поток класса ServletOutputStream, непосредственно расширяющего класс OutputStream. МеТОД getWriter () открывает символьный поток класса PrintWriter.

Итак, реализуя метод service!), надо получить информацию из входного потока объекта req, обработать ее и результат записать в выходной поток объекта resp.

Очень часто в объекте req содержится запрос к базе данных. В таком случае метод service о обращается через JDBC к базе данных и формирует ответ resp из полученного объекта ResultSet.

Создание архива

Jar-архивы создаются с помощью классов пакета java.util.jar или с помощью утилиты командной строки jar.
Правила применения утилиты jar очень похожи на правила применения утилиты tar. Набрав в командной строке слово jar и нажав клавишу , вы получите краткое пояснение, показанное на рис. П.1.
В строке
jar {ctxu}[vfmOM] [jar-file] [manifest-file] [-C dir] files...
зашифрованы правила применения утилиты. Фигурные скобки показывают, что после слова jar и пробела надо написать одну из букв с, t, x или и. Эти буквы означают следующие операции:
с (create) — создать новый архив;
t (table of contents) — вывести в стандартный вывод список содержимого архива;
х (extract) — извлечь из архива один или несколько файлов;
u (update) — обновить архив, заменив или добавив один или несколько файлов.

Рис. П.1.
Правила употребления утилиты jar
После буквы, без пробела, можно написать одну или несколько букв, перечисленных в квадратных скобках. Они означают следующее:
v (verbose) — выводить сообщения о процессе работы с архивом в стандартный вывод;
f (file) — записанный далее параметр jar-file показывает имя архивного файла;
m (manifest) — записанный далее параметр manifest-file показывает имя файла описания;
о (нуль) — не сжимать файлы, записывая их в архив;
м (manifest) — не создавать файл описания;
Параметр -i (index) предписывает создать
в
архиве файл INDEX.LIST. Он используется уже после формирования архивного файла.
После буквенных параметров-файлов через пробел записывается имя архивного файла jar-file, потом, через пробел, имя файла описания manifest-file, затем перечисляются имена файлов, которые надо занести в архив или извлечь из архива. Если это имена каталогов, то операция выполняется рекурсивно со всеми файлами каталога.
Перед первым именем каталога может стоять параметр -с. Конструкция -с dir означает, что на время выполнения утилиты jar текущим каталогом станет каталог dir. ,
Необязательные параметры занесены в квадратные скобки.

Итак, в конце командной строки должно быть записано хотя бы одно имя файла или каталога. Если среди параметров есть буква f, то первый из этих файлов понимается как архивный jar-файл. Если среди параметров находится буква т, то первый файл понимается как файл описания (manifest-file). Если среди параметров присутствуют обе буквы, то имя архивного файла и имя файла описания должны идти в том же порядке, что и буквы f и т.

Если параметр f и имя архивного файла отсутствуют, то архивным файлом будет служить стандартный вывод.

Рис. П.2.

Работа с утилитой jar

Если параметр m и имя файла описания отсутствуют, то по умолчанию файл MANIFEST.MF, лежащий в каталоге META-INF архивного файла, будет содержать только номер версии.

На рис. П.2 показан процесс создания архива Base.jar в каталоге ch3. Сначала показано содержимое каталога ch3. Затем создается архив, в который включается файл Base.class и все содержимое подкаталога classes. Снова выводится содержимое каталога ch3. В нем появляется файл Base.jar. Потом выводится содержимое архива.

Как видите, в архиве создан каталог META-INF, а в нем файл MANIFEST.MF.

Связь с базами данных через JDBC

Большинство информации хранится не в файлах, а в базах данных. Приложение должно уметь связываться с базой данных для получения из нее информации или для помещения информации в базу данных. Дело здесь осложняется тем, что СУБД (системы управления базами данных) сильно отличаются друг от друга и совершенно по-разному управляют базами данных. Каждая СУБД предоставляет свой набор функций для доступа к базам данных, и приходится для каждой СУБД писать свое приложение Но что делать при работе по сети, когда неизвестно, какая СУБД управляет базой на сервере?
Выход был найден корпорацией Microsoft, создавшей набор интерфейсов ODBC (Open Database Connectivity) для связи с базами данных, оформленных как прототипы функций языка С. Эти прототипы одинаковы для любой СУБД, они просто описывают набор действий с таблицами базы данных. В приложение, обращающееся к базе данных, записываются вызовы функций ODBC. Для каждой системы управления базами данных разрабатывается так называемый
драйвер ODBC,
реализующий эти функции для конкретной СУБД. Драйвер просматривает приложение, находит обращения к базе данных, передает их СУБД, получает от нее результаты и подставляет их в приложение. Идея оказалась очень удачной, и использование ODBC для работы с базами данных стало общепринятым.
Фирма SUN подхватила эту идею и разработала набор интерфейсов и классов, названный JDBC, предназначенный для работы с базами данных. Эти интерфейсы и классы составили пакет java.sqi, входящий в J2SDK Standard Edition, и его расширение javax.sql, входящее в J2SDK Enterprise Edition.
Кроме классов с методами доступа к базам данных для каждой СУБД необходим драйвер JDBC — промежуточная программа, реализующая методы JDBC. Существуют четыре типа драйверов JDBC.
1. Драйвер, реализующий методы JDBC вызовами функций ODBC. Это так называемый
мост
(bridge) JDBC-ODBC. Непосредственную связь с базой при этом осуществляет драйвер ODBC.
2. Драйвер, реализующий методы JDBC вызовами функций API самой СУБД.

3. Драйвер, реализующий методы JDBC вызовами функций сетевого протокола, независимого от СУБД. Этот протокол должен быть, затем, реализован средствами СУБД.

4. Драйвер, реализующий методы JDBC вызовами функций сетевого протокола СУБД.

Перед обращением к базе данных следует установить нужный драйвер, например, мост JDBC-ODBC:

try{

Class dr = sun.jdbc.odbc.JdbcOdbcDriver.class;

}catch(ClassNotFoundException e){

System.err.println("JDBC-ODBC bridge not found " + e);

}

Объект dr не понадобится в программе, но таков синтаксис. Другой способ установки драйвера показан в листинге П.1.

После того как драйвер установлен, надо связаться с базой данных. Методы связи описаны в интерфейсе connection. Экземпляр класса, реализующего этот интерфейс, можно получить одним из статических методов getConnection () класса DriverManager, например:

String url = "jdbc:odbc:mydb";

String login = "habib";

String password = "lnF4vb";

Connection qon = DriverManager.getConnection(url, login, password);

Обратите внимание на то, как формируется адрес базы данных url. Он начинается со строки "jdbc:", потом записывается

подпротокол

(subprotocol), в данном примере используется мост JDBC-ODBC, поэтому записывается "odbc:". Далее указывается адрес (subname) по правилам подпротокола, здесь просто имя локальной базы "mydb". Второй и третий аргументы — это имя и пароль для соединения с базой данных.

Если в вашей вычислительной системе установлен пакет javax.sql, то вместо класса DriverManager лучше использовать интерфейс DataSource.

Связавшись с базой данных, можно посылать запросы. Запрос хранится в объекте, реализующем интерфейс statement. Этот объект создается методом createstatement (), описанным в интерфейсе connection. Например:

Statement st = con.createStatement();

Затем запрос (query) заносится в этот объект методом execute () и потом выполняется методом getResultSet(). В простых случаях это можно сделать одним методом executeQuery (), например:

и все. Книга прочитана. Теперь

Ну вот и все. Книга прочитана. Теперь вы можете уверенно чувствовать себя в мире Java, свободно разбираться в новых технологиях и создавать свои приложения на самом современном уровне. Конечно, в этой книге мы не смогли подробно разобрать все аспекты технологии Java, но, зная основные приемы, вы сможете легко освоить все ее новые методы. Успехов вам!



---

---