asp.net mvc display pdf : Reader pdf reduce file size application software tool html windows wpf online Manning%20-%20Code%20Generation%20in%20Action26-part1346

232
CHAPTER 11
G
ENERATING
WEB
SERVICES
LAYERS
Authentication of the user of the web services interface is complicated by the fact
that both XML-RPC and SOAP are completely stateless. This means that every call to
the interface is its own complete transaction. There is no way to bundle a set of
method invocations together into a single transaction.
The two basic approaches to handling authentication in a stateless environment are:
• Using tickets—In this model, the client first requests a ticket from the server using
a specific method. The request contains the user’s authentication information
(i.e., the login and password). The client then sends the ticket along with all sub-
sequent requests.
• Authenticating on each request—In this model, the client sends authentication
information (i.e., the login and password) with each request.
Code generation is useful in either approach. The generator that builds the client and
server portions of the RPC code can hide from client users both the implementation of
the authentication model as well as the target API on the server.
On the client side, the generated API can have a login method that takes and stores
the authentication information. Then the API can either request a ticket or send the
information on each request. In this way, client code can remain the same even if the
authentication scheme changes.
On the server side, the set of authenticated logins can be cached locally within the
generated interface. Alternately, the authentication system in the business logic layer
or application server can be used, if such a system exists.
11.1.2
Why not use a library?
A library is often a valid approach to exporting a web services layer, so why generate the
layer? For C and C++, a library uses a set of structures to define a mapping layer,
which in turn defines the functions that are to be exported and their arguments. Other
languages, such as Java and C#, support reflection, which is a way of identifying the
methods of an object at runtime. RPC libraries make use of reflection by adjusting
their interfaces on the fly to match the methods of the exported objects.
Generation provides advantages in both environments:
• When using a static-mapping library for C or C++, the maps still need to be
maintained and synchronized with the application code. This type of mainte-
nance is an ideal task for code generation. 
• A reflection library may not be compatible with your business logic interface.
A generator can work in conjunction with the reflection library to create a com-
patible, intermediate layer.
In either case, the library will not supply you with client-side stub code that is tailored
to the web services interface you provide. The generators shown in this chapter repre-
sent examples not only of building the marshalling code for the server, but also of
Reader pdf reduce file size - Compress reduce PDF size in C#.net, ASP.NET, MVC, Ajax, WinForms, WPF
C# Code & .NET API to Compress & Decompress PDF Document
best way to compress pdf file; pdf custom paper size
Reader pdf reduce file size - VB.NET PDF File Compress Library: Compress reduce PDF size in vb.net, ASP.NET, MVC, Ajax, WinForms, WPF
VB.NET PDF Document Compression and Decompression Control SDK
reduce pdf file size; pdf page size limit
CASE
STUDY
GENERATING
XML-RPC 
FOR
J
AVA
233
building the client-side stubs at the same time so that the two interfaces—client and
server—are kept perfectly in sync.
11.2
CASE
STUDY
GENERATING
XML-RPC 
FOR
J
AVA
XML-RPC is an RPC layer on top of XML. It’s often compared to SOAP. Generally,
XML-RPC is considered to be of lighter weight and simpler than SOAP. 
The case study generator exports a simple library of functions through XML-RPC
using the Java XML-RPC library from Apache. We chose XML-RPC for the case
study because the implementation is generally smaller. However, the generation con-
cepts are portable between the two. 
Here are some terms specific to this case study and XML-RPC that you should
become familiar with:
• Target—This term applies to both classes and methods. The target class pro-
vides the web services that are exported through the XML-RPC layer. The tar-
get class is used as input to the generator to create the handler and stub
classes.
• Handler—The handler class wraps the 
target
class and has a set of han-
dler methods that map one to one with the exported methods of the target.
• Stub—The stub class contains all of the methods exported by the target
class. Each of these stub methods calls through the XML-RPC layer to talk
to the target class on the server. The value of a stub class is that it looks
and acts like a local class even though the implementation of the methods is on
the server.
• Client—The client makes use of the stub class to call target methods on
the server.
Our sample target class is fairly rudimentary. The class provides functions to add
numbers, subtract numbers, add strings, and perform other transformations that are
meant to test all of the types that can be exported through XML-RPC.
None of these methods holds any state. Neither XML-RPC nor SOAP provides
a mechanism for managing state across a session with the server. Every procedure
call is considered atomic. If your business logic layer requires managing state across
several method invocations to accomplish a single task, you will need to create an addi-
tional layer that provides a set of methods to accomplish each task in a completely
stateless manner.
VB.NET Image: Image Resizer Control SDK to Resize Picture & Photo
easy and developers can shrink or reduce source image NET Image SDK supported image file formats, including & profession imaging controls, PDF document, image
300 dpi pdf file size; pdf file size limit
C# Image: Zoom Image and Document Page in C#.NET Web Viewer
jpeg), gif, bmp (bitmap), tiff / multi-page tiff, PDF, etc. the web viewer will instantly enlarge or reduce the source file until the file size fits the
change font size pdf form reader; best way to compress pdf files
234
CHAPTER 11
G
ENERATING
WEB
SERVICES
LAYERS
Listing 11.1 contains the code for the test service.
import java.util.*;
public class Test
{
/**                                                               
* @rpcgen export                                                 
*/                                                               
public double add( double a, double b ) { return a+b; }
/**                                                               
* @rpcgen export                                                 
*/                                                               
public double subtract( double a, double b ) { return a-b; }      
/**
* @rpcgen export
*/
public boolean invert( boolean b ) { return ( b ? false : true ); }
/**
* @rpcgen export
*/
public int add_int( int a, int b ) { return a+b; }
/**
* @rpcgen export
*/
public int subtract_int( int a, int b ) { return a-b; }
/**
* @rpcgen export
*/
public String add_string( String a, String b ) { return a+" "+b; }
/**
* @rpcgen export
*/
public double add_array( Vector a )
{
double total = 0.0;
for( int index = 0; index < a.size(); index++ )
{
total += ((Double)a.get( index )).doubleValue();
}
return total;
}
/**
* @rpcgen export
*/
Listing 11.1 1 Test.java
Web service
methods
w
Markup for 
the generator
q
How to C#: Special Effects
filter will be applied to the image to reduce the noise. LinearStretch. Level the pixel between the black point and white point. Magnify. Double the image size.
can a pdf file be compressed; compress pdf
VB.NET Image: Compress & Decompress Document Image; RasterEdge .
reduce Word document size according to specific requirements in VB.NET; Scanned PDF encoding and decoding: compress a large size PDF document file for easier
change paper size pdf; pdf page size dimensions
CASE
STUDY
GENERATING
XML-RPC 
FOR
J
AVA
235
public String get_name( Hashtable ht )
return (String)ht.get( "name" );
}
}
q
Adding the @rpcgen marker to the JavaDoc tells the generator that this method
should be exported by the XML-RPC handler.
w
The methods in this class are the “services” our server will provide.
11.2.1
The XML-RPC message flow
First, the client initiates a call to the server by calling the 
add
method on the stub.
The stub in turn calls the test.add method on the server. Next, the XML-RPC
server invokes add on the handler object. The handler object creates an instance
of the target object and invokes add. The return value is then sent back to the
client class as the transaction unrolls. You can see this message flow between client
and target in figure 11.2.
Now let’s look at what you can expect this generator to do.
11.2.2
Roles of the generator
Before you build the generator, you need to specify its responsibilities. You should also
define the functions for which the generator is not responsible.
Client
add()
Stub
add()
Handler
Target
add()
test.add()
return()
return()
return()
return()
Figure 11.2 2 The XML-RPC flow for the 
add
method
View Images & Documents in Web Image Viewer | Online Tutorials
page document or image file, like Word, PDF or TIFF to help developers to decrease and reduce current zooming Reset the Size of Currently Viewed File via btnFit
best online pdf compressor; change font size in pdf form
VB.NET Image: How to Process & Edit Image Using VB.NET Image
Compact rich image editing functions into several small-size libraries that are VB.NET programmers the API to scale source image file (reduce or enlarge image
pdf compress; best pdf compressor
236
CHAPTER 11
G
ENERATING
WEB
SERVICES
LAYERS
The generator should create the following:
• The RPC layer, which includes:
•The server code that will handle the incoming XML-RPC methods and dis-
patch those requests to the correct application code.
•Stub client code that will be used by engineers building another system that
talks to our system.
• The technical documentation for the stub client code.
• Authentication of the client.
• Session management with the client.
The generator does not need to handle: 
• Design documentation for the application or the external RPC layer.
• Any functionality in the application layer.
The case study generator does not address authentication and session management
directly. These functions are application specific. I mention them here because authen-
tication and session management comprise the role of the RPC layer.
At this point, you can define the architecture of the generator.
11.2.3
Laying out the generator architecture
Your generator will build code for both the client and the server. On the server side,
you create handler code that will be used by XML-RPC to handle each message. On
the client side, you create stub code that will look like the target class to the engi-
neer but that will internally call to the server for every method.
For this generator, we chose to use a code munger model. The Java class should
have JavaDoc markup in it to tell you which methods require export. The generator
will read and analyze the Java file and create the appropriate handler and stub code.
Figure 11.3 shows the block architecture for the generator.
Generator
Handler
Handler
JavaCode
Handler
Method
Stubs
Stub
Method
Stubs
Client
Figure 11.3
The XML-RPC generator builds 
stubs and handlers from Java 
code with JavaDoc markup.
VB.NET Image: How to Zoom Web Images in Visual Basic .NET Imaging
and also some file types like PDF and multi out" functionality allows VB developers to easily reduce the size of web image or document file being displayed
advanced pdf compressor online; change page size pdf
C# Word: How to Compress, Decompress Word in C#.NET Projects
Efficiently reduce Microsoft Office Word document size using C# code; to compress the Word document file to a & profession imaging controls, PDF document, image
change paper size in pdf; change font size in pdf comment box
CASE
STUDY
GENERATING
XML-RPC 
FOR
J
AVA
237
In this architecture, the Java code acts as both input to the generator and as the
final target of the XML-RPC system. The generator uses a set of templates to build
the handler and stub Java code.
For this case study, you are only creating Java stubs. Keep in mind, though, that
there is no reason your generator couldn’t build stubs in a variety of languages.
Now let’s look at the steps the generator will go through as it runs.
11.2.4
Processing flow 
Here is the process flow of the generator, in high-level steps:
Reads the specified Java file.
Tokenizes the Java text.
Parses the Java text.
Creates a buffer that will hold both the client and stub methods text.
For each method, follows these steps:
Inspects the JavaDoc for the @rpcgen tag. If it has the tag, then it follows 
these steps:
Uses the StubMethod template to build the stub method and adds it to 
the buffer.
Uses the HandlerMethod template to build the handler method and adds 
it to the buffer.
Using the stub template and the stub method buffer, builds the Java class for the
stubs, and writes the result of that template to a Java file.
Using the handler template and the handler method buffer, builds the Java class
for the handler and writes that to the appropriate Java file.
11.2.5
Building the code for the XML-RPC generator
Now you’re ready to start writing the code for the generator. Listing 11.2 shows the
Ruby code for this generator.
require "CTokenizer"                                                  
require "JavaLanguageScanner"                                         
require "erb/erb"                                                     
require "ftools"
def read_java_file( file_name )                                        
print "Parsing #{file_name}...\n"
XML-RPC generator
Listing 11.2 2 rpcgen.rb
Imports Java 
tokenizer classes
q
Includes the 
ERb system
w
Main generator 
entry point
e
238
CHAPTER 11
G
ENERATING
WEB
SERVICES
LAYERS
fh = File.open( file_name )
in_text = fh.read()                                               
fh.close()                     
tokenizer = CTokenizer.new( )                                     
tokenizer.parse( in_text )                                        
languagescanner = JavaLanguageScanner.new()                       
languagescanner.parse( tokenizer.tokens )                               
file_prefix = file_name.sub( /[.]java$/, "" )                     
class_name = File.basename( file_name )                           
class_name.sub!( /[.]java$/, "" )                                 
handler_methods = ""                                              
stub_methods = ""                                                 
languagescanner.classes.each { |jclass|                              
jclass.methods.each { |proto|                                      
next unless proto.javadoc != nil                                 
next unless proto.javadoc.tags[ '@rpcgen' ]  != nil              
next unless proto.javadoc.tags[ '@rpcgen' ] =~ /export/          
method_name = proto.method_name                                  
method_type = proto.method_type                                  
arguments = proto.arguments                                      
handler_methods += run_template( "HandlerMethod.java", binding ) 
stub_methods += run_template( "StubMethod.java", binding )       
}                                                                  
}
handler_name = "#{file_prefix}Handler.java"                         
print "Creating #{handler_name}\n"                                  
fh = File.open( handler_name, "w" )                                 
methods = handler_methods                                           
fh.print run_template( "Handler.java.template", binding )           
fh.close()                                                          
stubs_name = "#{file_prefix}Stubs.java"                             
print "Creating #{stubs_name}\n"                                      
fh = File.open( stubs_name, "w" )                                     
methods = stub_methods                                                
fh.print run_template( "Stubs.java.template", binding )               
fh.close()                                                            
end
def rpc_type( type )                                                   
return "Double" if ( type == "double" )                                            
return "Integer" if ( type == "int" )
return "Boolean" if ( type == "boolean" )
return type
end
def run_template( template_name, bind )                              
erb = ERb.new( File.new( "templates/#{template_name}" ).read )
return erb.result( bind )
end
Creates the handler
Java file with
server methods
t
Tokenizes 
Java
Uses the filename 
as the class name
Creates the stub 
and handler buffer
Parses tokens
Removes the 
Java extension
Calls an ERb wrapper 
to run a template
Returns the corresponding 
RPC type for the Java type
u
Creates the client
stubs file with
stub methods
y
Iterates each class and builds
server and stub code
r
Reads the 
Java file
CASE
STUDY
GENERATING
XML-RPC 
FOR
J
AVA
239
if ARGV[0]
read_java_file( ARGV[ 0 ] )                                       
else
print "Must specify an input C file\n"
end
q
You use CTokenizer and JavaLanguageScanner to tokenize the Java file and
then parse it to find the JavaDoc comments.
w
You use ERb to invoke the templates that build the Java code.
e
read_java_file is the main entry point for the generator. It reads in a Java file and
builds the stub and handler code.
r
This code builds the handler and stub methods. It iterates through each of the methods
in the class and checks to see if the JavaDoc contains the @rpcgen tag. If it does, the
templates are added for both the handler and the stub.
t
This code uses Handler.java.template to build the handler Java file. The tem-
plate requires the class name and the methods.
y
This code uses Stubs.java.template to build the stubs Java file. The template
requires the class name and the methods.
u
rpc_type returns the XML-RPC wrapper type for the given Java type. 
For each method, you want to export a corresponding handler method. To auto-
mate this, create the template HandlerMethod.java, which builds a handler method
(listing 11.3).
<%
out_type = rpc_type( method_type )                       
args = []                                                
call_args = []                                           
arguments.each { |arg|                                   
type = arg.type                                        
name = arg.name
args.push( "#{type} #{name}" )
call_args.push( "#{name}" )
}
%>
public <%= out_type %> <%= method_name %><%= args.join( ", " ) %>          
{
<%= class_name %> obj = new <%= class_name %>();                      
return new <%= out_type %>( obj.<%= method_name %><%= call_args.join
( ", " ) %> ) );
}
Sends the command 
line to the generator 
Listing 11.3 3 HandlerMethod.java
Gets the correct Java type 
for the RPC type
q
Interprets 
arguments to 
the function
w
Creates the
Java method
signature
e
Builds the 
server class
r
240
CHAPTER 11
G
ENERATING
WEB
SERVICES
LAYERS
q
This template needs to create a method of the type that you are wrapping, then call a
method on it and return the output value. The out_type is the XML-RPC return type.
w
In this section, you are creating two sets of arguments. The args array contains the
arguments for this method, and call_args is the array of arguments that you will
send to the method of the type you are wrapping.
e
This code builds the method signature.
r
This code creates the object of the type that you are wrapping, and then calls the target
method and sends back the return value.   
Once you have all of the handler methods, put them into a class container. Listing 11.4
contains the class container template.
import java.util.*;
/** 
* XML-RPC wrapper for the <%= class_name %> class.
*/
public class <%= class_name %>                             
{
<%= methods %>                                             
}
Listing 11.5 shows the final output of the generator using the handler method and
handler container templates.
import java.util.*;
/**
* XML-RPC wrapper for the Test class.
*/
public class TestHandler
{
public Double add( double a, double b )                                 
{
Test obj = new Test();                                                
return new Double( obj.add( a, b ) );                                 
}
public Double subtract( double a, double b )
{
Test obj = new Test();
return new Double( obj.subtract( a, b ) ); 
}
Listing 11.4 4 Handler.java.template
Creates the proper 
class name
Adds 
methods
Listing 11.5 5 TestHandler.java output 
Shows the new 
double handler
q
Creates the original server class
w
Invokes the original 
class method
e
CASE
STUDY
GENERATING
XML-RPC 
FOR
J
AVA
241
public Boolean invert( boolean b )
{
Test obj = new Test();
return new Boolean( obj.invert( b ) );
}
public Integer add_int( int a, int b )
{
Test obj = new Test();
return new Integer( obj.add_int( a, b ) );
}
public Integer subtract_int( int a, int b )
{
Test obj = new Test();
return new Integer( obj.subtract_int( a, b ) );
}
public String add_string( String a, String b )
{
Test obj = new Test();
return new String( obj.add_string( a, b ) );
}
public Double add_array( Vector a )
{
Test obj = new Test();
return new Double( obj.add_array( a ) );
}
public String get_name( Hashtable ht )
{
Test obj = new Test();
return new String( obj.get_name( ht ) );
}
}
q
This is the signature that the XML-RPC library looks for when choosing methods
to export. If you use Double instead of double, the method will not be exported
by the XML-RPC server. The generator handles marshalling between Double and
double as well as the other types.
w
Because you are wrapping a class type, you first have to create an instance of that class.
e
Now you invoke the corresponding method on the instance of the class. 
Documents you may be interested
Documents you may be interested