Пешеходна обиколка на JavaBeans

Предишна 1 2 Страница 2 Страница 2 от 2

Какво е JavaBeans и какво прави

JavaBeans не е продукт, програма или среда за разработка. Това е както основният пакет Java ( java.beans), който Beans може да използва за предоставена разширена функционалност, така и документ ( спецификацията JavaBeans ), който описва как да се използват класовете и интерфейсите в java.beansпакета за реализиране на „Beans функционалност“. Спецификацията на класа е част от основната версия на Java 1.1 и затова не трябва да се инсталира допълнителен софтуер, за да се използва. Добавянето на Beans изискваше малка промяна в езика Java сам по себе си, въпреки че няколко нови и изключително необходими приложни програмни интерфейса бяха добавени към основната версия, за да поддържат Beans функции. Четенето на спецификацията може да бъде информативно, но сънливо. За щастие не е задължително, ако вече разбирате как и защо да използвате пакета JavaBeans. Може би вече разбирате Beans, като прочетете забавна и просветляваща поредица статии за JavaBeans в JavaWorld , например.

JavaBeans превръща класовете в софтуерни компоненти, като предоставя няколко нови функции. Някои от тези функции са специфични за Beans. Други, като сериализацията, могат да се прилагат за всеки клас, Bean или по друг начин, но са от решаващо значение за разбирането и използването на Beans.

Софтуерните компоненти имат свойства , които са атрибути на обекта. Персонализирането е процес на конфигуриране на Bean за конкретна задача. Новата схема за обработка на събития в Java 1.1 е създадена отчасти за улесняване на комуникацията между Beans. Фасулът може да бъде дисектиран от IDE или от други класове чрез процес, наречен интроспекция . Зърната могат да бъдат постоянни (т.е. сериализирани ) в байтови потоци за предаване или съхранение, а постоянните зърна могат да бъдат пакетирани в „JAR файлове“, за да се улесни изтеглянето и достъпа. И накрая, Beans са проектирани да си взаимодействат лесно с наследени компонентни технологии като ActiveX и LiveConnect и участвайте в транзакции със системи за брокер на обектни заявки като CORBA.

Нека разгледаме всяка една от тези възможности малко по-задълбочено.

Свойства и персонализация

Както е отбелязано по-горе, свойствата са атрибути на Bean. Визуалните свойства могат да включват цвят или размер на екрана. Други свойства може да нямат визуално представяне: например Bean BrowserHistory Bean може да има свойство, указващо максималния брой URL адреси за съхранение. Фасулите излагат setter и getter методите (наречени "методи за достъп") за техните свойства, позволявайки на други класове или IDE да манипулират тяхното състояние. Процесът на настройване на свойствата на Bean по време на проектиране или изпълнение се нарича персонализиране .

Разработчикът има голям контрол върху достъпа и модификацията на свойствата на Beans. За просто свойство разработчикът пише метод, наречен setProperty()и друг извикан getProperty().

Тук щяхте да видите аплет, но по някаква причина не можете.

BarChart

Например, ако използвате браузър с активирана Java, ще видите аплет, който използва малък клас, наречен BarChart. Това BarChartе цветната лента между двата бутона. BarChartлипсва само едно нещо, за да се превърне в Bean: той не реализира интерфейса java.io.Serializable(защото повечето браузъри все още не се справят с Java 1.1 и затова примерният аплет ще се провали.)

С изключение на това, че BarChartе сериализуем, е прост Bean, само с много малко методи. Има void setPercent(int pct), което залива дъното pct процента от лентата с червено. Методът int getPercent()връща текущия процент, съхраняван в Bean (това е състоянието на Bean). В setPercent()метода призовава също така repaint(), ако тя се промени процента, така че визуално представяне на облегалките на обекта в крак с времето.

Кодът на аплета се извиква setPercent(getPercent()+10)при натискане на бутона + 10% , което кара BarChartда увеличава процента си (ако е <100%). Процент е пример за свойство Bean , с методи за задаване и получаване, посочени в съответствие със спецификацията JavaBeans. Тъй като тази поредица продължава, ще превърнем това малко смирено BarChartв полезен софтуерен компонент, който може да бъде включен в различни приложения.

Стойността на индексирано свойство е масив. Методите за достъп на индексираните свойства получават и връщат масиви от стойности вместо скалари. Методите за достъп могат да хвърлят проверени изключения, за да докладват за грешки.

Понякога е полезно дадено действие да се случи, когато дадено свойство на обект се промени. Обвързаните свойства карат събитията да се изпращат към други обекти, когато стойността на свойството се промени, евентуално позволявайки на получателя да предприеме някакви действия. Така че, SpreadSheet Bean може да бъде конфигуриран да казва на PieChart Bean да се прерисува всеки път, когато данните на електронната таблица се променят.

Често определени стойности за свойства са незаконни въз основа на състоянието на други зърна. Bean може да бъде настроен да „слуша“ тези ограничени свойства на други Bean и „veto“ промени, които не харесва. Например, ядреният реактор ControlRodArray Bean може да иска да попречи на някой, който се опитва да промени състоянието на DrainReactorCorePump Bean на ON, ако контролните пръти са извадени. (Не правете това у дома си. Вероятно никой не трябва да се използва JavaBeans за такива приложения просто все още.)

Когато разработчик свързва Beans заедно, за да създаде приложение, IDE може да представи лист със свойства, съдържащ всички свойства на Beans и техните текущи стойности. (Листът със свойства е диалогов прозорец, използван за задаване и / или преглед на свойства, като това, което получавате, като изберете Опции ... в менюто.) Разработчикът задава свойствата графично, което IDE превръща в извиквания на методите за задаване на Beans, промяна на състоянието на боб. Това персонализира Beans за конкретното приложение.

Използването на списъци със свойства не винаги е най-добрият начин да се справите с персонализирането на Beans. Някои зърна имат състояние, което е твърде сложно, за да бъде лесно манипулирано по този начин. Другите зърна просто биха били по-готини, ако имаше по-интуитивен начин да ги настроите. Представете си лошия мениджър, който просто иска да разгледа отчетите за продажбите и трябва да разбере какво да напише в текстовото поле "Отдалечен източник на данни ODBC" в лист със свойства. Няма ли да е по-хладно, ако тя може просто да плъзне и пусне иконата на DataSource Bean (персонализирана с етикета „Данни за продажби“, разбира се) върху DataConnection Bean, като по този начин я конфигурира автоматично? Разработчик на Beans може да вгради лист със свойства в самия Bean и IDE след това използва този "персонализатор", за да персонализира Bean.

Съответните класове за манипулиране на свойства и персонализиране са в java.beansпакета.

Обработка на събития

Цялото това взаимодействие между Beans предполага някакъв начин за комуникация между тях. JDK 1.1 дефинира нов модел на събитие, който класовете (не само Beans!) Използват за комуникация. В действителност, този нов модел събитие е намерил своя път в една от най-широко използваните пакети на Java: java.awt!

В новия модел на събитие клас регистрира интерес към дейностите на друг клас чрез интерфейс на слушател . Всъщност целевият обект (заинтересованата страна) казва на обекта източник (обекта на интерес): „Уведомете ме, когато се случи така и така“. Когато се случи така и така, обектът-източник „задейства“ събитие в целта, като извиква манипулатора на събитието на целта с подклас на EventObjectкато аргумент.

Събитията могат да се използват за внедряване на обвързани и ограничени свойства. В PieChart и електронни таблици примера по-горе, "регистри" PieChart интерес към всяка промяна на електронната таблица (нека да кажат) DataList собственост. Когато SpreadSheet ще промени свойството си DataList , той предава DataListChangedEvent(подкласиран от EventObject), указващ какво се е променило, на всеки метод за обработка на събития на заинтересуван слушател. След това целта ( PieChart) изследва събитието и предприема подходящи действия.

Примерът за ядрен реактор работи по подобен начин; но в този случай целта налага вето на промяната, като хвърля изключение. Така светът се спасява от широко разпространеното радиоактивно унищожаване.

Най- EventObjectкласа може да бъде разширена, за да създадете потребителски дефинирани събития . Класовете вече могат да дефинират и използват нови типове събития, за да изпращат съобщения един към друг. Това означава, че Beans, работещи в същия контейнер, могат да комуникират, като предават съобщения наоколо. Това помага да се разделят зависимостите между обектите, които знаем, че е много добро нещо.

Дефинираните от потребителя (и други) събития се извличат от класа java.util.EventObject.

Самоанализ

Доста странният термин за самоанализ е Java-speak за процеса на програмно анализиране на публичните методи и членове на класа. Този процес понякога се нарича и откритие . Новият механизъм за отражение в ядрото на Java, който може да дисектира обект и да върне описание на съдържанието му, прави възможна самоанализ. (Въпреки че Java може да бъде отразяваща, дори интроспективна, омфалоскепсисът все още не е част от основното разпространение.)

Вече сме срещали едно приложение с тази възможност. По-горе описахме IDE, която може да изгради списък на свойствата на Bean, които да представи на разработчик. Как може IDE да знае какви свойства има Bean? IDE открива свойствата на Bean по един от двата начина: чрез искане на Bean за описание на неговите свойства или чрез дисекция на Bean чрез интроспекция.

Типичната IDE ще започне с искане на Bean за обект BeanInfo, който, наред с други неща, описва свойствата на Bean. След това IDE ще използва обекта BeanInfo за изграждане на лист със свойства. (Това предполага, че Bean не предоставя свой собствен персонализатор.) Ако Bean не знае как да върне обект BeanInfo, IDE след това извършва самоанализ на Bean и сканира списъка с методи за имена, започващи с set и вземете . Той приема (по конвенция), че тези методи са аксесоари за свойства и създава нов лист със свойства, базиран на съществуващите методи за достъп и типовете аргументи, които тези методи приемат. Така че, ако методите за IDE находки обичат setColor(Color), Color getColor(), setSize(Size), и Size getSize(), след което тя ще създаде собственост лист със свойстватаЦвят и размер и подходящо въведени джаджи за тяхното задаване.

Това означава, че ако разработчикът просто следва конвенциите за именуване на методи за достъп, IDE може автоматично да определи как да създаде лист за персонализиране на компонента.

Механизмът за отражение, който извършва самоанализ, е в новия езиков пакет java.lang.reflect.

Устойчивост и опаковка

Често е полезно да се „суши чрез замразяване“ обект чрез преобразуване на състоянието му в блок данни, който да се опакова за по-нататъшна употреба - или да се предаде чрез мрежа за обработка другаде. Този процес се нарича сериализация и е нова функция на ядрото на Java.

Едно от най-простите приложения за сериализация е да се запази състоянието на персонализиран Bean, така че новоизградените свойства на Bean да могат да бъдат правилно зададени по време на изпълнение.

Също така сериализацията е основен елемент на технологията на компонентите, което прави възможни схеми за разпределена обработка като CORBA. Ако обектът няма локално информацията, която му е необходима, за да изпълни задачата си, той може да се изпрати до посредник за заявки, който сериализира обекта и го изпраща другаде за обработка. На отдалечения край обектът се възстановява и се извършва първоначално заявената операция. Това също е начин за реализиране на балансиране на натоварването (за скъпи задачи, тоест: сериализацията и десериализацията често не са евтини).

Къде държите група лиофилизирани бобчета, които са били „мариновани“ по този начин? Защо, в JAR, разбира се! Спецификацията JavaBeans описва JAR файл като структуриран ZIP файл, съдържащ множество сериализирани обекти, документация, изображения, файлове с класове и т.н., с манифест, който описва какво има в JAR. JAR файл, съдържащ много компресирани малки файлове, може да бъде изтеглен изцяло и декомпресиран в края на клиента, което прави изтеглянето на аплета (например) по-ефективно. (JAR е доста очевидно игра на Unix tar файлов формат.)

В java.ioпакета осигурява обект сериализация. Спецификацията JavaBeans описва формата на JAR файловете.

Взаимодействие

Някой маниак веднъж каза, че хубавото на стандартите е, че има толкова много, от които да избирате. Компонентните технологии не са изключение. Има много съществуващи системи, базирани на OLE (или последното му въплъщение, ActiveX), OpenDoc и LiveConnect. JavaBeans е проектиран да (поне в крайна сметка) да си взаимодейства с тези други компонентни технологии.

Не е реалистично да очакваме разработчиците да се откажат от съществуващите инвестиции в други технологии и да изпълнят всичко в Java. След пускането на Java 1.1, първите Bean / ActiveX „мостови“ комплекти са налични, което позволява на разработчиците да свързват Beans и ActiveX компонентите безпроблемно в едно и също приложение. Java IDL интерфейсът, който ще позволи на Java класовете да работят със съществуващите системи CORBA, излиза тази година.

Въпреки че Beans / ActiveX мостът и Java IDL не са част от стандартната дистрибуция на JavaBeans, те закръглят възможностите на JavaBeans като индустриална, отворена технология за преносим компонент софтуер.

Заключение

Покрихме много земя. В тази статия научихте какво представляват софтуерните компоненти и защо те са ценни. След това научихте за различните свойства на JavaBeans, включително свойства, персонализиране, събития, самоанализ, постоянство, опаковане и взаимодействие със стари компонентни системи.

В следващата статия от тази поредица ще започнем да използвате JavaBeans и ще разгледаме подробно свойствата на Bean: как работят и как да направите своя Beans персонализиран. Докато продължаваме, ще обсъдим новите основни функции на Java, които правят Beans възможен. Бъдещите статии от тази поредица ще задълбочат подробностите по темите, които обсъдихме този месец.

Марк Джонсън има бакалавърска степен по компютърна и електротехника от университета Пърдю (1986). Той има 15 години опит в програмирането в C и две години в C ++ и е фанатичен привърженик на подхода Design Pattern в обектно-ориентираната архитектура, на софтуерните компоненти на теория и на JavaBeans на практика. През последните няколко години той работи за Kodak, Booz-Allen и Hamilton и EDS в Мексико Сити, разработвайки приложения за бази данни Oracle и Informix за Мексиканския федерален избирателен институт и за мексиканските митници. Той прекара последната година в NETdelivery, интернет стартиращ сега в Боулдър, Колорадо. Марк е програмист на Unix и вижда Java като липсваща връзка между сега повсеместните настолни клиентски системи и отворени, разпространени, и мащабируеми корпоративни фонове.В момента работи като дизайнер и разработчик на обектни продукти във Форт Колинс, Колорадо.

Научете повече за тази тема

  • Отлично сравнение на JavaBeans и ActiveX може да се намери в историята на корицата за JavaWorld на Merlin Hughes , "JavaBeans и ActiveX вървят главата до главата"

    //www.javaworld.com/javaworld/jw-03-1997/jw-03-avb-tech.html

  • Sun Microsystems поддържа уеб сайт за JavaBeans. На този сайт можете да изтеглите най-новия BDK (Комплект за разработчици на зърна), да прочетете спецификацията на JavaBeans, да сърфирате в онлайн урок и да разберете най-новата информация за Beans. //java.sun.com/beans
  • В JavaBeans Advisor , случаен електронен бюлетин, съдържащ Фасул новини и разработчик съвети, се архивира в

    //splash.javasoft.com/beans/Advisor.html

  • В JavaBeans Често задавани въпроси , поддържан от Sun е най-

    //splash.javasoft.com/beans/FAQ.html

  • И накрая, омфалоскепсисът е форма на интроспективна медитация, включваща интензивно съзерцание на пъпа. Разгледайте уеб сайта Word A Day и запълнете ежедневната си реч с неясни препратки! //www.wordsmith.org/awad/index.html

Тази история „Пешеходна обиколка на JavaBeans“ първоначално е публикувана от JavaWorld.