WWDC2001 Session 614

Transcript

Kind: captions
Language: en
so thank you and welcome to session 614
I know it's pretty late and you all want
to get a hold of some beer so I tried to
make it quick the session is about
advanced Java client I want to start out
by summarizing little bit what we heard
in this session 609 and 606 and then we
want to go into a lot more details about
the distribution here so let me start by
summarizing that what we learned so far
so Java client is a technology for
distributed desktop applications right
it's a three-tier architecture the
client interacts with the user it
displays the user interface you use the
Java foundation classes or swing for
that so we are basically
platform-independent
the server accesses the database and the
database does the Tia which stores the
data the client never accesses the
database directly all the communication
from the client to the database goes
through the server so the server has
complete control over everything the
client is allowed to do and what and not
and also what's interesting to know is
that the communication protocol between
client and server at least by default is
HTTP so you get the connectivity of a of
an HTML based application running in the
browser but it's a much richer user
interface and Java client is mostly
designed for the intranet
it's their couple of complications that
either the launch time or you know the
amount of data you need to download or
you decline installation so it's not a
good technology for you to put on high
traffic internet sites now jonathan is
actually pretty powerful and it's very
very prepared for a lot of advanced
tasks but since we do not have too much
documentation at this time a few of the
features are relatively hidden but I
think you should really know about them
so I will try to talk about you know
very concrete method names this time
notification names and I hope that you
know you can all take something away
from here you know to really tune your
applications so first of all I want to
go enough detail about the distribution
there and the objects in the
distribution area
I want to talk a little bit about issues
that you have to know about when you're
going to go into deployment with your
applications and if you say at the time
I'd like to use and talk a little more
about the controller factories that
comes from Exedy they direct a Java
client side and I'm show you how can use
it to implement some nice features so
you've probably seen this diagram before
I don't want to go through all these
boxes again but I want to kind of point
out about which of the pieces in this
architecture I'm going to talk because
well the distribution layer is the layer
that connects the client and the server
that's where I would spend most of the
time and then at the end we talked about
the factory if you be in the e
generation they are right at the top so
that stuff is some object some
information about the distribution layer
and the most important topic when it
comes to the distribution layer to me is
business logic petitioning in Java
client you can have implementations of
your business logic both on the client
and the server side the business objects
are fully functioning on both sides of
the architecture and you have the choice
to either use the same identical
business logic or you can use what we
call petition business logic and
petition business look business logic
simply means that you use different
implementations on both sides of the
architecture and so far I always you
know and I started talking about it I
said you know the first thing you can do
is you can restrict the visibility of
properties to the server side so that
they are not visible on the client side
I want to make it a bit more complicated
for the purpose of this session because
you can also add additional properties
that they're only visible on the client
side but not on the server side now how
does that make sense well you know
sometimes you're not interested in all
the information a lot of detail
information you just are interested in
derived properties so let's say you have
an object that stores dimensions like a
bid hide in the debt and on the client
you really only want to see the volume
of the complete object so what you can
do is you can add an additional property
to your model actually and markets only
as a client side that
and then the UN you do not invade the
height and depth so that detailed
attributes you know would stay on the
server side and the client side you only
use a derived attribute you also have
the choice to use different
implementations so if you want to you
know perform computations in different
ways
the implementation of the Business
Objects in use can be different first of
all that adds a lot of security to your
application because you never sent data
or even implementations to the client
that you don't want the client to see
right now the Java you should probably
know that all the classes you sent to
the client can easily be decompiled so
if you have you know computations
algorithms that you considered you know
secret you don't want the you know to be
ever become public on any client side
then you can force the client to use an
implementation on the server side so you
can make force the client to make a
round trip to the server execute the
computation there then just send the end
result back it's a no data and no
implementation that you don't want the
client to see will ever go there and
business repetition also has a lot of
performance optimization something that
probably today but really fast client
machines doesn't matter so much anymore
but if you have very fast server
machines and relatively slow client
machines you can design your clients to
make use of the computation power of the
server boxes but as I said it probably
doesn't matter too much anymore
but what's what actually is important is
that you can use business logic
petitioning to minimize the amount of
data that's transferred between server
and client if you have computations that
need to take a look at a lot of data but
you didn't fetch a lot of objects from
the database to just get an end result
but you only want to display this end
result you don't want to send or the
detailed data that you need for the
computation there's no need for you to
send it to the client you just design
your client to make a round-trip to the
server right execute the computation
there and on the way back you just send
to reside and other data that is needed
for the computation does not have to be
sent over the wire to the client side if
you think that that's one of the keys to
be successful with Java client that you
find the right petitioning of your
business logic
right the key really is to minimize the
amount of data that is transferred if
you define it server
how do you tell UF to use business logic
petitioning where you just go into your
modeler and if you want to use different
implementations usually where you choose
a different class usually in your model
if you look at an entity you have a
column where you can enter a class name
the Java client you can actually you
know unhide another column called the
client psychic last name and you
actually find it in this add column
popup menu that you see at the bottom of
the table and in here you can specify a
different class name I don't know
whether you can read it but in the
example that I use here you know the
packages are example.com in the credit
card but in the first row and it's
actually the same on both client and
server side but for example in the
second row I use example dot server that
customer and example our client our
customers so there are two classes but
in two different packages and on the
client I used a different implementation
and on the server side the other thing
you can do any of your modelers you can
if you actually look at the detail of of
an entity if you look at all the
properties and relationships you're
probably familiar with the column to set
class properties so these are the
properties you you know that actually
make it into your business logic and
your business objects and for Java
client you can again unhide another
column you can set the client side class
properties so here you know you can in
this case actually restrict it declines
the visibility of the member sins and
the phone attributes so they only
visible on the server but not on the
client
if you improve you know the methods you
use to implement business logic
petitioning or defined a new enterprise
object the most important one you
probably need to know about is invoke
remote method that's the method you need
you invoke on the client side to make it
you know to and you use it to basically
move the execution of method to the
server side so if you want to go from
the client to the server you use invoke
remote method the arguments you pass are
first about the editing context the
object is in a method name the argument
types the arguments themselves so this
is the you know the method name of the
augment types identify the method that
is supposed to be invoked on the server
side if you invoke invoke remote method
what happens is that the state of the
editing context on the client side is
basically pushed to the server side to
the editing context on the server side
and then the method that you specified
the last three arguments method named
argument types its invoked on the server
side objects on the equivalent server
side object and there are two more
methods that are helpful for you and
they they use them on the server side
and they evade from client update and
prepare values for client those are
basically notifications to the business
object that something has happens on the
client side that the object has been
updated on the client side and you can
use it you know to perform additional
validation or if you you know you can do
computations basically its notification
that helps you know the client the
values for this object were changed on
the client side right and prepare values
for client is involved right before the
object is sent back right when you
central reside back to the client before
the object is encoded right to be
transferred we invoke prepare values for
clients so if you have derived
attributes that the only visible on the
client side vary from client up and
prepare values for client are very
useful it you can basically you know
delay the computation of the derived
values until the invoke prepare values
for client again the order is on the
client side we invoke you invoke invoke
remote method on the server side evade
from client update ism
and the method remote method X is
performed before the object is sent back
me invoke prepare that is for client
there's a very important naming
conventionally used for remote method
invocations
the naming convention is that if the
name of the method starts with
client-side requests then we considered
a method that is you know open for
unrestricted access from any client if
your method does not start with the
client side request and then actually
there's a security mechanism in place I
talk a little more about it later
you can use to restrict the access of
methods to serve clients something that
is now possible in though objects 5 but
was not possible about it's 4.5 is that
now you can use common super classes for
your business logic implementations in
web objects four five four five four
four five one the server side was
implemented in Objective C the client
side was implemented in Java right in
Objective C we had a wrapped API so the
superclass was some you know in server
side package so you generic record you
custom object vendor in the server side
package and the client you know had a
different implementation of the
superclass so for client side business
object in the server side business
object you couldn't use the common
superclass but that's actually possibly
now and that opens the door for you know
a lot of good design actually so what I
recommend to you is that you use common
super classes for the two
implementations and just define methods
abstract right that you want to have
different under both on both sides and
then you you implement a client subclass
that they were mode method invocations
in the server subclass that the concrete
computations let me show you an example
so this slide shows you know roughly how
you know a class secret would look like
at this time I'm sub classing a generic
record as you can see the package there
shows this example that common import
chrome web object you control it's just
business logic I don't need anything
more then you know I would implement
shared functionality and other methods
and the methods that I won't have
different
I declare abstract
for the client-side unis I use a
different package the page is not
example the client and the class doesn't
extend Eugene egg record anymore it
extends my superclass the one that I
just created example comment secret and
the implementation of secret value
performs the remote method invocation as
you can see I'm using our naming
convention clients at request here said
something easier for me I don't have to
worry about the security restrictions
then and the method that I invoke takes
no arguments that's why I and the end of
the invoker mode method you know if
there are no arguments you can just pass
not on the server side again I use a
different package example dot server
again you know the class again extends
the common superclass and now the method
secret where you actually implement some
of your business logic as you can see
it's been complicated here but then
there's a second method its clients that
week first secret value so this is the
method the client actually invokes and
it then invokes the vir method right so
this is the the design pattern that I
recommend to you and the convenience or
the the communion this is convenient
because you can write business logic
your code against the abstract
superclass right it's available on both
sides you don't have to worry about you
know the complete package if you want to
reference the class from other classes
from other code you would write it
against the shared superclass right this
is abstract but for the since the API is
defined already as abstract methods you
know you can compile against it and then
it happens to resolve to the concrete
subclasses and the different packages at
runtime
let's take a look at the objects that
made this happen
there are four objects I want to point
out to you two on the server side for
Java client applet and your distribution
context and two on the client side you
distributed object store in your
distribution channel actually you HD
feature and as you'll see later the Vote
Java client applet is a web objects
component it lives under don't get
confused with the name that there's an
applet in there it's a web objects
component living on the server side and
it's responsible for generating the
applet tag if you it has a lot of
bindings you know some specific to
happen to the applet like the width and
the height the code base but it also has
bindings really specific to you know
Java client for example the name of the
application class the name of the
distribution channel as you will see
later if you use direct Java client you
have a binding that you can use to
specify the class of the controller
Factory and so therefore Java client
applet is the object the basically
prison well through which all the
communication from the client goes if
the client contacts the server it
actually talks to this object the Vote
Java client Apted about its component
that the instantiated on the server side
now you might wonder how that all works
if you start the application the client
application is a desktop application not
as an applet if you serve it as in
desktop at the next if you do create a
void Java client applet but we don't
really need it in that case but we
decided to do it anyway because it gives
you one single place that you can
configure your client right we basically
use the bindings of the boat Java client
applet that you define that you can
define to both initialize applets as
well as desktop applications so the
advantage for you is you don't have to
worry about whether your client runs us
an application or whether your client
runs it's an asset it's the same code
path that is executed all the time and
there's one place on the server side in
the code on the server side we can
initialize or we can specify all the
parameters for the client and usually
you know if you want to change some of
the bindings just open the you know
is the main component go develop objects
builder and the inspector and change or
the binding step the other important
object in the server-side is the EU
distribution context the new
distribution context is the object that
performs all the work right when it
comes to Java client it's the object
that keeps track of a lot of state
already it tracks which objects have
been fetched by the client it's the
object that basically you know takes
care of synchronizing editing content
business data on the client and the
service side and you know we could have
made the bow Java client applet and the
you distribution context the same object
well that probably would have been
pretty poor object design and second of
all as you will see later you actually
have the choice to change the
communication protocol if you don't want
to use our way of communication if you
don't want to go you know to avoid Java
client app that you can plug in your own
mechanism and so you would still use the
ear distribution context right so the
Vote driver kind a participates is the
object that you know who sees messages
but just forwarded to the distribution
context and this and the distribution
context is where all that work is
performed on the client side the two
important objects are a distributed
object so in your distribution channel
the you distributed object store is
another type of root object store it
basically replaces the you database
context that you might be familiar with
the distribution of it this will be the
object so X as the parent object store
for the editing context so the editing
context fetch or save data they go
through the distributed object store and
the disability object store basically
makes the client behave like in nested
editing context to the server side the
decision and every distributed object
stored in this video officer uses a
distribution channel to actually perform
the communication so the distribution
channel is responsible for sending the
data from the client to the server and
it's the you distribution trainer is
actually an abstract class and you will
usually use the concrete subclass you
HTTP channel but if you don't like it
you can plug in your own
way of communication I know that you all
like pictures so I have one for you so
if an editing context you know on the
client side fetches data it will
actually go through a distributed object
store which we use the distribution
channel right to perform it to the
communication with the server side in
the server side the Vote Java client
applet the instance of what Java
connected that he created it's the
object that receives the request it
forwards it to the distribution context
and that one and you know usually access
to the editing context the default
editing context of the session to
actually you know take a look at the
data so the four objects that introduce
to you the distributed object store the
distribution channel the Java client or
Java client Apted in the distribution
context those who opted to work together
to connect the editing context on the
client side to the editing context on
the server side now that we knew the
distributed object store there's some
actually an API I want to mention to you
the new distributed object store can
easily be found because it's through the
object store
there's API on your object store default
good object store this is that one
default rule parent sorry about that
you'll find it so it's actually very
easy to to access the irresolute object
store and it has an API that a generic
API you can use to perform remote method
invocation so if you have something you
need from the server that it's not
related to business logic you know
something that you need in your
application of logic maybe you know
information about what kind of resources
are available maybe you know you want to
handle user defaults in a special way
then you can use this method here and
it's takes similar parameters than the
one that we found on a way enterprise
object it takes an editing context the
reason I'll talk about in a minute it
takes to keep path it actually
identifies the objects on the object on
the server side that receives the method
but if you invoke it on an enterprise
object it's clear which object is to
receive on the and the server side
because you know there's one version of
the business object on the client one
version on the server side you
there's an equivalent on the server side
so if you know exactly where to send a
method but for the generic API game you
have to specify where to send it
the other arguments method name argument
types and arguments you already know and
there's another flag push changes so the
method the the arguments entity constant
push changes I think you would probably
not need them very often but if you
remote method invocation is related to
some kind of business logic you can pass
the inedited context and this method
here will make sure that the state of
that editing context is synchronized
with the server side editing context
okay so if you're if you need the latest
state of the business logic on the
server of the business data on the
server side you can pass the editing
context and for push changes you pass
true and then the the distribution layer
would take care of synchronizing the
state of the editing context you pass to
this method here and the edited
countries on the server side let's take
a look at the key path for a moment
there are three ways you can describe
the target of the remote method
invocation first of all you can pass
just knife for the key path if you do
that the distribution area assumes that
you want to invoke the method on the
distribution context directly it's
pretty rare and on our default mutation
of your distribution context there's
probably nothing you want to invoke if
you subclasses of distribution context
this might come in handy more common is
probably that you pass an empty string
an empty string indicates to the
distribution area that you want to
invoke a method on this what we call a
distribution target the distribution
context on the server side has a
registry for arbitrary objects you can
just add additional objects right to
registry and when there's a remote
method invocation the distribution
context may search through these targets
and find the first one that implements
the method you described and invoke the
method on it so these in invocation
targets are very convenient way to
basically extend the functionality of
the distribution context right there's
nothing the object will really be
arbitrary you know any class
that's just fine just has to implement
the method you want to invoke and the
method has to be public by the way now
the question is how do you register
additional targets because you know why
the server is running there might be
clients that are instantiated there's
not just one distribution context for
every client this and distribution
context so to help you we send out a
notification and it's called
EU remote method receive a needed
notification it's a very long name so
use copy/paste but if you register for
this notification receive it you can use
the notification to add your invocation
targets so basically you could make for
example your application object you can
you can register your application object
for this notification and then in the
notification the user introductory you
actually find the distribution context
that was just created so then the
session yeah so then the client connects
to the server will send up this
notification and it will contain the
distribution context and then you can
use it to add your you know method
receivers and if you don't person I and
if you don't pass an empty string then
the diffusion layer zooms that the the
key path actually identifies an object
relative to the distribution context for
example it could be a session write a
distribution context has a method
session so if you person specify certain
you know we will follow the key path the
string you interpreted as a key path
starting at the distribution context you
know go to the target and use that bonus
the method you want to send the
definites the object you want to send
the method to again even for this
generic API we use the naming convention
client-side requests so if your method
name starts to cancer breakfast it's
it's an open for unrestricted access
we talked a little bit more about
distribution centers as I said the
distribution centers are responsible for
transferring the data between client and
server and as I said there's an abstract
class a distribution channel and there's
a concrete subclass new HTTP channel you
were probably on most of the case you
would stick with the EU HTTP channel if
you don't like it at all you can
implement your own subclass or your
distribution channel and instead instead
it's fairly complicated so you know if
you can try to stick to the UDP channel
if you want to change the class of the
distribution channel there's a binding
in the word Java client applet that you
can change they can specify the new
class name that you want to use on your
HTTP channel there's one method that is
particularly important because if you
want to do things like connecting to SSA
then you can override this one method
here create socket you pass the protocol
of the URL the host name and the port
number to create a different kind of
socket for example in SI saket not
actually like to show you an example my
name is Eric and running through SSA and
back to us Nova chats to come up on
stage and drive to demo for me so if you
could switch to the demo machine for our
demo purposes here we used a package
called jss e that you can download from
Sam's website it's basically some kind
of reference implementation for for
secure socket layer and we have the code
that we had to write on the client side
for the channel here on the screen so as
you can see there's a class as a channel
extending our new HTTP channel and if
you focus for a moment on the create
socket method first check of our check
whether it's actually using HTTP if not
we just use you know the superclass
fermentations so this socket this
division channel actually supports both
protocols and if it's HTTP then the only
thing we have to do is to use you know
the stasis e djc classes to create an
SSH socket said if you parametres and
return this new socket it's that easy
that's basically all you have to do and
decline
so now if you look at the static
relation initialized at the top and
there are two things we have to do make
sure I had to write down on why that is
so the first line enables the HTTP
protocol in the URL handler and the
other one registers as a security
provider so these two things we had to
do these two methods we had invoked to
register you know the jss implementation
with the system to be able to use the
socket okay I think now we just like to
run the applications so that you know
that it works
so the service starting and so far we
obviously use this Java client launcher
program
I think it's minimizing the darker so
it's at the right side this time you
want to show you actually the strip that
we're using so we wrote it in script and
it's very simple
it basically but it's based on the
script that the budget generates for you
anyway if you compile client
applications if you we always create you
know launch script for you for the
server side that we also create the
script for the client side if you just
use that one and then the difference is
if you pass in the UAE as you can see we
use HTTP and the past additional
arguments which is genic last name and
there's our new channel class so let's
execute the script
and then hopefully in a second we would
see an application that we just
generated with the assistant it's a
nothing fancy about the application but
it connects to SSN so there's actually
not a lot of code you have to write on
the client side to do it to make that
happen may actually turn out to us that
it's much more complicated to configure
apache to allow us to do SSA than you
know to implement the client side
and there's our client so there's
nothing special about you've probably
seen this before but the difference is
now it's connecting to SSA so it's
reading thank you know what let's sit
back to the slides thank you a lot of
features all of the hooks that you need
to use I implemented or available to you
in the form of delegates there are two
objects where you can set a delegate for
one is on the server side one's on the
client side again and the server side is
on the you distribution context the you
know various delegate methods you can
implement just to list what you can do
I'm festival you can encrypt and decrypt
the communication so everybody that is
sent between client and server you can
apply your own encryption mechanism to I
think it's probably more convenient for
you to just use SSA or something like
that you if you want to implement your
own encryption mechanism you have
delegate methods so you can control
every single by the dissent between
client and server you can also control
the access you know if the client then
fetching Business Objects basically
there's delegate method you can control
exactly which objects the client is
allowed to fetch so if you don't want to
make an entity object of an entity
visible to the client can use delegate
and just say no you can see there sorry
and the third hope you have in the
delegate is that you can restrict the
invocation of remote method invocations
but if you don't follow the naming
convention clients that request then by
default we do not allow you allow the
client still work any other method but
you can use to delegate to open up the
method invocation so for every remote
method invocation that the client tries
to perform the day delegate will be
notified and can you know on a client
basis determine whether this method can
be executed on the server or not so
those are pretty strong security
features you on the client side in the
you distribution channel you can also
handle encryption decryption but this is
the other way around both client and
server offices need to work together
otherwise you get a lot of mess but
yeah so and the second piece is the
second hook in the in delegate of the
distribution channel is that you can
deal with exceptions there are two types
of exceptions you can get one is an i/o
exception something went wrong with your
communication right maybe something you
can't open a socket you know maybe the
network just went down something like
that there's an exception like that the
delegate can handle it it can try to
reconnect maybe but it's up to you but
there's another type of exceptions that
happen quite often and that is that
something on the server right there's
nothing wrong with the communication but
there's an exception raised on the
server side maybe a validation error
right maybe variation method on the
server side of the business logic on the
server side raise an exception and then
you can handle those kinds of exceptions
with the delegate another very common
accepted by the way is session timeout
right so the delegate has a way to deal
with all these kinds of exceptions the
timing is pretty important for setting
the delegates because especially or
especially if you do encryption
decryption you have to make sure that
the delegates are in place before the
first byte is transferred right and the
delegate needs to be in place on both
sides of the architecture so the best
way for you to set delegate is on the
server side but then by receiving
registering for another type of
notification it's the you distribution
distribution context instantiated
notification you send it out whenever
created is to a distribution context and
there you can set a delegate right and
on the client side the best way for you
to set the delegate of the distribution
channel is by using an subclass of your
application and going to the constructor
it's really the only place that you have
you know to apply your own to plug in
your own logic before we make the first
round trip if you don't do in Krypton
and decryption you can do it later but
you know if you have to you would have
if it's if you use encryption decryption
then you would have to use an
application your application subclass
and like not to talk a little bit more
about deployment issues first of all I'd
like to go over the system requirements
for the server side the Java
client/server server application it's a
standard object education wherever you
can deploy a bit object server you can
deploy it above your server for Java
client on the client side
the only thing view quite is jdk 1.3
that does contains thing now that was
different in the earlier times the jdk
one-on-one aid now jdk 1.3 contains
things so there's no need to download it
anymore
on a cos 10 mecha-suits probably the
best platform to deploy Java client
applications because JDK 1 / 2 is
integrated in the operating system very
convenient
on Windows and you have to download it
from Suns website and unfortunately on
Mac OS 9
there's no JDK 1.3 support so you will
not be able to deploy them the two
options you have the Java client for
deployment are desktop applications or
applets if you deploy desktop
application you would create a little
launch program on Mac OS 10 we probably
use project builder or there's another
tool called MOJ a beta on Windows you
would probably just readily launch
script and then create a shortcut to it
from the desktop if you deploy an applet
on mecca's 10 again it's relatively easy
if you would probably use Internet
Explorer which comes with the system and
browsers on mecca's 10 use the java vm
that comes with the operating system
that's pretty nice on Windows for both
Netscape we you probably require to use
the Java plug-in but for IE microsoft
has not committed to jdk 1.2 or 1.3
support
I think Netscape has but you know
depends on the version of Netscape that
you use so the best way around this is
to use the Java plug-in which Sun
provides again it can be downloaded from
Suns websites available to everybody and
Java client is actually pretty smart
about this and use JavaScript to detect
the client configuration
so we do the right thing for you but you
can just say yes please use the Java
plug-in you'll find out that if it's on
necklace 10 you know if you don't have
to use it its integrated in the
operating system if it's on windows 4 ie
and Netscape you do the right thing
users will be pointed automatically to
son's website they can download the
plug-in and then everything is fine just
to show you how easy it is to create a
launch program I'd like to ask Noah to
come up again and what we want to do is
we want to create a launch program for
the application we just generated the SS
edge that they just demoed before the
SSL demo and that's actually pretty nice
because we can demo a few features of
the new project builder that come in
very handy so the first thing you do is
we create a new project and this time we
just choose a java application template
it's not even a web object template if
you give it a name call it is a launcher
and this is a pretty simple project it
has a Java class it has an icon fire so
you can drag in your own I can if you
want this is the default I could be we
get and that's the properties fire maybe
we go ahead and change some of these
properties make should be already load
them so just that they don't make any
mistakes why we give this demo here
first of all we will switch the main
class we would specify typical class if
you use the Java client common object to
your application your application and
then also we will use a property that is
understood by the mrj and this is these
are basically parameters that are passed
the main function in your application so
here we specify the application you are
a write using HTTP again if you specify
the chana class name as a demo client
SSH and
so these are basically the parameters
that we pass on the command line when we
use the script you just you know put
them in this properties file here
in addition to that we want to create if
you know an application that contains
all the Java classes that we need so we
will drag a few jar fights and here we
put them all in one convenient directory
here the Java fights that we added first
of all the word Java client a jar you
find that in system library Java and it
contains all the UF client-side classes
there there are three Java files that
come with Jas is e you just drop them in
there and there's the SSA demo dot jar
that is the that is the client side of
our application so it contains our
channel class and I think the interface
controller that we needed for the client
side and then something I would like to
point out here is yeah please go to the
targets you can activate that you can
ask project builder to integrate all
these jar files into your application so
we activate the merge option here and
what that we do it for us is that all
the Java classes inside these jar files
that we specified we end up inside your
application right so it's going to be
nicely packaged for you for deployment
let me
just take a moment because actually a
lot of classes needs to merge together
in one jar fire
so this is really convenient in the new
project video
okay that's it and are we just started
I mean it won't look very different from
before but the nice thing is now we have
you know a desktop application it's it's
self-contained you can take this one app
you contribute to the client that's all
you have to do very nice
what's happening that is so that's our
client nothing special about it okay
thank you know it puts it back to the
slides
okay I'd like to go again through the
deployment options and compare the two
deployment options and this is basically
going to be a repetition of what we've
heard so far but I think it's very
important to understand so the biggest
advantage of an applet is the simplicity
of the client installation because when
the applet starts up it downloads all
the classes from the server side if it
needs to execute the client program so
if you want to upgrade your application
if you want to ship a new version of the
client you just have to you know install
the new classes on the server side and
when the clients start up the next time
the applets they just pick up the new
classes so that's very convenient for
you to handle the applications you first
we have to create this launch program
and then you have to install it on the
client and on the client it has to you
know you have to have all the Java
classes available on there on the client
side so if you want to upgrade your a
little bit of traveling because you have
to make sure that all your client
applicator or end users right upgrade to
the new version
so the alarms of the applet is really
dead installation and upgrading is so
easy on the other side the applications
provide a much better user experience
just much more convenient for the user
to have a desktop application that can
be accessed through you know student
icon on the desktop that is completely
embedded in the desktop environment you
know you can hide the application you
can minimize windows you have access to
service menus you don't have to put the
applet so the user experience is much
nicer also applications perform a little
better than applets that's mostly
because applications run very isolated
applets in one browser might have good
efforts in one browser actually share
the same Java VM so they can have all
kinds of negative side effects both on
the performance and the stability side
that's not something you should be it
would be happy about as as an
application developer but applications
are isolated if you know if another java
application is running it doesn't affect
us if it crashes if it doesn't that's
something bad that the system it doesn't
affect the the java application also
from your perspective as the application
developer you don't have to deal with
security restrictions on the client-side
in a place there's a security manager in
place
usually prevents untrusted code to
execute to access the file system right
the applications you don't have to worry
about that because there's no security
manager right you can do everything you
need to do on the client side and users
might see that it different and that's
why it got a little dot here because you
know that applets
they know if it's untrusted code that
the Java VM will prevent the update from
messing around to the computer so they
might actually like to execute at this
this other side if you're in internet
environments it probably doesn't matter
so much because hopefully your end users
trust the system administrator to pass
out good software the last thing that
this can come in very handy with
applications that you have full control
over all the Java VM parameters if you
need a special heap size or you know you
actually you want to choose the VM you
want to execute in you can do some of
the applications and applets you don't
have any control over that it could
compromise from my perspective is when
it comes you know in the in regards to
installation upgrading to use a special
class loader for the client application
the base system doesn't change that
often the base system would be the JDK
1.3 and all our UF Java client classes
so it's actually a very good idea to
install those classes on the client side
and then to download all the classes
that are specific to your application
there's actually exactly what we do with
this Java client launcher that we used
in the previous demos you know we didn't
have to configure the client in any
special way the reason was that it
contacted the server first of all asked
it what kind of classes are specific to
this client right downloaded those
classes even before it went into the UF
code and so that's very convenient
because you know the base doesn't change
that often it's on the client but you
still get you know a fair amount of
upgrade ability with the special class
loader because you can upgrade the
client classes on the server side you
can make it available on the server side
and you only take a small hit because
they're usually not that many specific
classes to your application
it's maybe 50 classes or so that's
pretty quick to download right so you
probably take a hit of you know one to
three seconds at startup time but the
benefit you know of of you for you to to
be able to upgrade the client
applications quickly and fix bugs in an
elegant way without having to worry
about you know shipping another
installer and making sure that all the
clients really install it
that's quite compelling the next two
points session time mods and server
instances I received a lot of questions
about that so Java client on the server
side uses normally both sessions and the
client connects the credible session
objects object and sessions have you
know sessions time out the problem that
you know usually not a problem except
that users of desktop applications
usually don't expect that but I mean if
you know if I'm running an app in the
browser I can understand by a session
times out but if I use a desktop
application that I just double clicked I
don't you know you didn't see this
concept of session timeouts so to help
you Java client explicitly notifies the
server if the user hits the application
right so what that means is that if the
client you know it's terminated cleanly
so you know the user chooses the quit
command then we actually make an
round-trip to the server
hey I'm gone and the server within clean
up that session so for most of your
clients right you shouldn't have to
worry about the session time of the
session you know not terminating because
it would explicitly notify the server
the only sessions that might stay around
is if you know maybe the network
connection went down the user had
decided to kill the application
something like that so there might be a
few sessions you know of not cleanly
terminated applications to stay around
but that shouldn't really bother you so
the best way to leave the session
timeouts is to use a very large timeout
maybe 24 hours maybe in 48 hours that
way users that started the desktop
application
you know southern in the morning then
maybe they went for lunch come back
three four hours later maybe had a few
meetings in between but they don't face
session timeouts and it shouldn't
concern you that the sessions are around
let's talk about server instance for a
moment Java client with Java kind you
could scared the server side in the
normal way like that every other web
object education if you serve a lot of
clients at the same time just use much
with server instances something they
might have I'd like to give you a little
more information so that you can you
know better understand what's going on
the clients some information that might
help you to determine how many services
you need the first thing you should know
about Java client is that there's
usually a very high load at startup
right
often there are classes that have to be
downloaded especially if you're honest
applets if you start a Java client
there's some kind of UI information
being exchanged also you know users
usually start out in the beginning you
know to search for objects they want to
work with so that's usually high load at
startup and then afterwards it uses just
you know relatively small packages
and actually for the same amount of data
the communication the Java client the
the package size for the data it's not
smaller than the HTML so if you you know
have five objects you want to say in
HTML you know all the HTML around it if
you compare that to the encoded stream
of data that we use for Java client the
Java can stream is much more compact
it's really nicely compacted business
data now the fact that the packages are
smaller doesn't mean that you will never
have a problem with the communication
and what I would like to point out is
that usually you know in intranet
applications the amount of business data
that the client wants to access it's
much larger so what the message is
really for the same amount of data
there's no you don't have to worry about
Java client you know creating a lot of
data to be transferred but be careful
because in internet applications most
users will access more data than they do
you know in the internet or they maybe
have a new shopping basket or so that's
not a lot of data there
okay and I think we actually do have
enough time so I'd like to talk a little
more about the controller Factory the
controller Factory is the object in the
center of dr. Java clients than am using
the face generation it's the object
that's responsible to communicate with
the server to request you know a
description of the client-side user
interface it's responsible for
instantiated or the controller
hierarchies that you use on the client
side but the controller Factory is not
only useful in dynamically generated
applications you can make use of it you
know it's actually very convenient
sometimes to make stand empty created
user interfaces and statically generated
user interfaces so lip fight such a
tenet in interface builder the factory
provides a good amount of API that you
can use to retrieve you know additional
configuration information from the root
system and also provide some API you
know to create controllers and vendors
on some kind of an action basis so if
you need something like a modal dialog
to quickly select a few objects and you
don't want to go into interface builder
set up this compute you know the window
of the more dialog and lay out all the
digits again you can just use a method
on the controller Factory and we
probably you know do the right thing so
some of the methods I just listed here
select the entity name would create a
modal dialog that the user can choose an
object open global IDs with entity name
it would pass a set of global IDs and
you would get a set of form windows if
you want you know the user wants you
want to use it to insert a new object
you can ask the factory to create a
window that insert the entity name and
you know the creative in it but the user
can enter the new data there's also more
low-level API and to retrieve what we
call primitive controllers you can
consider a primitive controller to be a
small unit in the UI basically related
to one entity and one task so for
example in the query window usually have
very primitive controller and the list
primitive controller right every query
pane in the claim you know usually we
usually consists of two primitive
controllers and there's a pretty large
API just a few methods here to a
controller with entity less controller
and form control over that
but you can use and actually like to
show you how you can use these methods
to implement some nice features so no
but it's coming up again cuz if you
switch to the demo machine so here we
have a prepared application and I think
we first want to start it
so the service started and now we used
to Java plane launch again to launch the
client there already is
so you're connecting to the server now
see the nice thing about this Java time
conscious that you can even launch the
client before the service there because
the wait until all the classes are
downloaded right if we wait until we
connect and then download the classes
and then start then jump into VF code so
here's our application it looks pretty
normal if I don't move that window a
little more to the left and it looks
like basically the winner we could have
created with the assistant this
especially menu item in this application
that the ADA discards configure and we
will you know if you get a little
configuration tool which happens to look
very similar to the assistant that you
usually use now let's just have know
about play around a little bit there and
see what happens
so he's removing some of the attributes
there and he's switching to list
okay doing the same thing there
now what's the bender on the left side
and we press the apply button so the UI
automatically actually configures to
this new to this layout so what we kind
of simulate here is a UI where the
end-user can actually choose what kind
of data he or she wants to see right
it's like a user configurable UI let's
take a look at the source code we had to
write for that so why don't you quit the
client okay that's fine so the class
interesting is JC dynamic which is a
subclass of you interface controller and
that's all the code we had to write so
the important method here is update user
interface we invoke it both in the
constructor of the interface controller
and it's also invoked when we press on
the default on the apply button and this
tool in the configuration tool and as
you can see the only thing we do is if
there is Orion editor to remove the old
one then we create a new one that they
have the controller factory and actually
the primitive controller you know it's
one controller as much with SAP contours
it's a little hierarchy of controller
status response before you know this
this editor part and he sets this
controller in there so we use a method a
new controller
it's called controller of the key value
pairs which this is a method that it
works through a hierarchy of controllers
you know and looks for a matching
controller for this this key value pair
and then we just set a relationship
paths so that's basically the connection
of the list controller
you know the detail controller to the
master detail to the master interface
and we add the sub controller so that's
all the code we have to write for that
so the controller factory is really
useful for you if you want to have some
kind of user configurable UI and why
don't you press on the g JC application
so this is you know code that would be
much more complicated for you would
obviously have to come over to view to
it for the user to you know to enter the
configuration data but we made it easy
if you just use some kind of a you know
simplified assistant here and the most
important piece actually if you scroll
up again there's a method defaults which
we overrode and you just use especially
defaults class as you can see in the
constructor here and so this is basic
just to register for whenever the user
defaults change
right then the Refresh the use interface
that's all of you okay thank you know
about so just to repeat what we did if
you want to come up with a user
configurable UI you would have to you
know will actually use the word system
right I mean if you use it an empty
generated piece and the user interface
so we you would have to write a rule to
retrieve you know the list of properties
the user really chose so you would have
to create some kind of a you know a
database a configuration store it could
be you know and the file system can be
in the database and in the interface
file or actually sorry I forgot about
that could be switch do you still have
that open in IV just close okay it
doesn't matter what we did in the
interface file is the best created it
with the assistant and then just remove
the whole lower portion of the user of
the Lib file and replace it with an
empty box within its custom view and we
told the interface controller that this
is the so called sub controller area the
sub controller areas is you know way for
for us to point the controller to view
where all the sub views of dynamic
generated UI should be placed and so we
have to read rule in the world system
right to create to retrieve the list of
properties on a user basis we would have
to go into the interface file as you
remove everything that we want to create
an a McLean replace it with an empty box
and then we have to after a little bit
of code that dynamically swaps
sub-controllers and as I said you use
the API on the factory to retrieve
primitive AP primitive controllers so
for some in this controller with the
entity and then obviously and probably
the most complicated part he would have
provided to like a preferences panel so
where the user can configure the data
it's not number okay so in summary Java
client is very powerful it's prepared
for a lot of advanced tasks the most
important objects are the new
distribution context on the server side
and the you distributed object store on
the client side let's mention mentioned
about Java client applet and the new
distribution channel I think most of the
time you do not work with them directly
but you use distribution context with
the users with the object store and the
delegates for those objects distribution
channels are customizable it's actually
pretty easy as you sort of plug-in SSA
again you have multiple options to
deploy you can deploy its desktop
application or as an applet and the
controller factory is a useful thing to
look at even if you you know don't want
to leave the traditional development if
you still on the works of interface
files and generate most of the pieces of
the UI by hand and the controller
Factory might make your life easier it's
really worth to take a look at it okay I
think typically slides at the end and
the lab actually closes now it's open
tomorrow again at 10:30 please vote for
the objects as the best app server and
those are the persons to contact Tony
our director and Bob and product
marketing and I services
you