asp.net mvc display pdf : Change font size pdf SDK control service wpf web page .net dnn Manning%20-%20Code%20Generation%20in%20Action23-part1343

202
CHAPTER 10
C
REATING
DATABASE
ACCESS
GENERATORS
The following pseudo-code fragment shows how a new entity is created within
the server:
// From the page:
ValueObject valueObject = new ValueObject()
// ... Fill the value object ...
SSHome ssHome = jndi lookup("SS path")
SS ss = ssHome.create()
ss.add(valueObject) 
// Inside Stateless Session Bean on server:
EntityHome entityHome = jndi lookup("Entity path")
Entity entity = entityHome.create( params, copied, from, value, object )
With a requirement to build five-plus classes and two interfaces for every entity in your
application, you’ll find the generator to be a valuable development tool.
Deployment descriptors
In addition to the beans, the application server needs XML deployment descriptors.
These deployment descriptors tell the application server details about the application,
such as what beans are available, what type of persistence they use, and their transac-
tional requirements.
Because the generator builds all of the beans, it is easy for it to create the deploy-
ment descriptors for the beans as well. This is important because these descriptor files
can be complex and difficult to maintain by hand. In addition, deployment descrip-
tors have vendor-specific elements that could be maintained at the generator level,
which allows for portability to other application servers.
Now you’re ready to define the responsibilities of your case study generator.
10.5.4
Roles of the generator
For this project, your database generator should maintain all of the persistence and
query logic as well as the business logic. This means that the database generator takes
responsibility for these tasks:
• All database operations, including all UPDATEINSERT, and DELETE statements.
• All queries against the database.
• The business logic.
• The physical schema of the database.
• Any stored procedures used to implement the database operations or queries.
• Testing systems to support the testing of the database access layer.
Change font size pdf - Compress reduce PDF size in C#.net, ASP.NET, MVC, Ajax, WinForms, WPF
C# Code & .NET API to Compress & Decompress PDF Document
pdf file size limit; best pdf compressor
Change font size pdf - 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
best way to compress pdf files; reduce pdf file size
CASE
STUDY
: EJB 
GENERATION
203
The generator will not handle the following:
• Storage of any preferences associated with a single session with the application
interface.
• Export of the data to other systems or import of data from other systems (though
import/export code will make extensive use of the database code).
• The user interface validations or the workflow patterns for usability.
Of course, the list of responsibilities will vary for each generator.
Some architectures will separate the persistence function from the business logic.
This is a valid approach, and if you use it, you should make sure that you have des-
ignated which portions of the code the generator is responsible for before design and
construction of the generator begins.
Whether you buy a generator or use an open source generator, you should make
sure that the role of the generator is clear and well understood.
10.5.5
Laying out the generator architecture
Our case study generator is called EJBGen (not to be confused with the EJBGen cur-
rently in the public domain). The generator takes three definition files as input. The
first is the schema.xml file, which contains the definition for all of the tables, fields, and
the relationships within the schema. The next file is extensions.xml, which contains
extra queries and custom business logic. These extra queries can be used as the back
end for specialized reports. The third is samples.xml, which contains sample data used
to pre-load the database through the database access layer. Figure 10.5 shows the inputs
and outputs to the EJB generator.
Generator
SchemaDefinition
File
EJBEntityBeans
EntityBean
EntityHome
SQLTable
EJBSessionBeans
Deployment
Descriptors
Initialization
SQL
Session
Deployment
Descriptor
TestPage
JSPTestPages
Session
Home
BusinessLogic
DefinitionFile
SampleData
Entity
Session
Bean
SampleDataLoader
ProductionJSPPages
DB
Figure 10.5 5 The generator builds the EJB code, schema, and deployment descriptors 
for a Java database tier.
C# PDF insert text Library: insert text into PDF content in C#.net
Powerful .NET PDF edit control allows modify existing scanned PDF text. Ability to change text font, color, size and location and output a new PDF document.
change paper size in pdf document; change font size in fillable pdf
C# PDF Annotate Library: Draw, edit PDF annotation, markups in C#.
Able to edit and change PDF annotation properties such as font size or color. Abilities to draw markups on PDF document or stamp on PDF file.
pdf file size; change font size pdf form reader
204
CHAPTER 10
C
REATING
DATABASE
ACCESS
GENERATORS
As you can see, the outputs and their corresponding templates are numerous.
Figure 10.6 shows where the outputs from the generator sit within the full architecture
of a web application.
In the figure, the solid bordered boxes are the domain of the EJB generator.
Central to the output is the database access layer that sits between the user interface
layer and the database. The database server could be any modern relational database,
such as SQLServer, Oracle, MySQL, or PostgreSQL.
We decided to use an all open source EJB solution to build the case study.
The architecture uses Tomcat as the web server, JBoss as the application server, and
PostgreSQL as the database engine.
Let’s take a look at the outputs:
• EJBs—The primary output of the generator is the set of EJBs that represent the
entities in your book database. These EJBs provide both database persistence and
business logic. In some architectures, a business logic layer sits between the user
interface and the database access layer. With this generator, the business logic is
folded into the database access layer by use of the extensions.xml definition file
described in section 10.5.8.
• SQL definition file—One of the key advantages of the case study generator is the
synchronization of the physical schema in the database to the field and object
definitions in the application. To make that happen, the generator needs to build
the SQL table construction code. In this case study, the generator creates a single
SQL command file that builds the tables, creates any sequence generators, and
then constructs any relationships between the tables.
• Deployment descriptors—As you’ll recall, one of the responsibilities of the genera-
tor is to maintain these XML deployment descriptor files. The deployment
descriptors bind the beans to the application server. These files are tedious to main-
tain by hand, so there is real value in the generator’s ability to maintain these files.
• Test JSPs—Nothing is complete until you can test it, so the first step in this case is
to actually see the data appear on the web server using JSPs. To that end, you can
have the generator build, add, delete, and update pages for each entity type. In
addition, you can create simple reports that list all of the entities within the
system, as well as create display pages for any custom queries that you generate.
UserInterface
DatabaseAccess
TestPages
Database
DatabaseDefinition
SampleDataLoader
Figure 10.6
A J2EE web application architecture
C# PDF Sticky Note Library: add, delete, update PDF note in C#.net
Allow users to add comments online in ASPX webpage. Able to change font size in PDF comment box. Able to save and print sticky notes in PDF file.
pdf paper size; adjust pdf page size
C# PDF Convert to Word SDK: Convert PDF to Word library in C#.net
PDF document, keeps the elements (like images, tables and chats) of original PDF file and maintains the original text style (including font, size, color, links
apple compress pdf; change font size in fillable pdf form
CASE
STUDY
: EJB 
GENERATION
205
• Sample data import through the stateless session facade—In addition to creating
end-user test pages with the JSPs, you can create a set of routines that will load
the database using your EJB layer. Using the EJBs to add new data to the data-
base is a first-level check that your EJBs are working and that the database is
responding the way you want. The presence of known sample data in the system
will also allow you to create end-to-end system tests for your database access layer.
10.5.6
Processing flow 
The case study EJB generator follows the tier generator model that reads a definition
file and uses templates to build a number of output files. The generator follows this
process flow:
Reads the schema file and stores it internally.
Creates the SQL schema file.
Reads the extensions file.
Reads the sample data.
For each table follows these steps:
Builds the entity, entity bean, and entity home.
For each value object follows these steps:
Builds the value object Java file.
Builds the test JSP file.
Creates the stateless session, stateless session bean, and stateless session home.
Creates the add, update, and delete JSP files for testing.
For each query creates a JSP file.
Creates the index JSP file, which points to all of the test pages.
Creates the stateless session factory class.
Creates the deployment descriptors.
Creates the sample data loader.
Whenever the process indicates that we are creating a file, you use a template to build
the output file. This use of templates keeps the logic code for the generator separate
from the formatting of the output code.
A key aspect of this generator is that the templates are merely output handlers. The
brains of the generator are in the core Ruby code. This centralization of knowledge
is important to ensure that all of the templates are given the correct interpretation of
the definition files. If the interpretation of the definition files were left to each of the
templates (as is the case in other generators in this book), then two templates could
interpret field definitions differently, causing disparity across the output files. 
EJB generator
Generate Barcodes in Web Image Viewer| Online Tutorials
Select "Generate" to process barcode generation; Change Barcode Properties. Select "Font" to choose human-readable text font style, color, size and effects;
acrobat compress pdf; change font size in pdf fillable form
C# PDF Field Edit Library: insert, delete, update pdf form field
Able to add text field to specified PDF file position in C#.NET class. Support to change font size in PDF form. Able to delete form fields from adobe PDF file.
pdf compressor; change font size in pdf file
206
CHAPTER 10
C
REATING
DATABASE
ACCESS
GENERATORS
10.5.7
The schema definition
Three definition files (schema, extensions, and sample data) go into the generator. The
central definition file is the schema file, which contains the table definitions, the field
definitions, and the table relationship specifications. Here is the schema definition for
this case study:
<schema package="gen" jndi-prefix="gen">
<table name="Book">
<column name="bookID" datatype="integer" not-null="true"
primary-key="true" /> 
<column name="title" datatype="varchar" length="80" not-null="true" />   
<column name="ISBN" datatype="varchar" length="80" not-null="true"
unique="true" /> 
<column name="authorID" datatype="integer" not-null="true" />
<column name="publisherID" datatype="integer" not-null="true" />
<column name="status" datatype="integer" not-null="true" />
<column name="numCopies" datatype="integer" not-null="true" />
</table>
<table name="Author">
<column name="authorID" datatype="integer" not-null="true"              
primary-key="true" />
<column name="name" datatype="varchar" length="80" not-null="true"
unique="true" />
<column name="penName" datatype="varchar" length="80" />
</table>
<table name="Publisher">
<column name="publisherID" datatype="integer" not-null="true"
primary-key="true" />
<column name="name" datatype="varchar" length="80" not-null="true"
unique="true" />
</table>
<foreign-key>
<fk-table>Book</fk-table>
<fk-column>authorID</fk-column>
<fk-references>Author</fk-references>
</foreign-key> 
<foreign-key>
<fk-table>Book</fk-table>
<fk-column>publisherID</fk-column>
<fk-references>Publisher</fk-references>
</foreign-key>
</schema>
q
The schema tag defines the Java package name and the prefix for use with JNDI.
Inside the schema tags are all of the table tags, which define the different tables, and
the foreign-key tag, which defines the relations between each table.
e
The Author
table
The Book
table
w
The main 
schema node
q
r
The
Publisher
table
t
Relationship
between books
and authors
y
Relationship
between books
and publishers
VB.NET Image: Visual Basic .NET Guide to Draw Text on Image in .
Please note that you can change some of the example, you can adjust the text font, font size, font type (regular LoadImage) Dim DrawFont As New Font("Arial", 16
advanced pdf compressor online; change font size on pdf text box
C# Image: Use C# Class to Insert Callout Annotation on Images
Easy to set annotation filled font property individually Support adjusting callout annotation size parameter in an easy way; C# demo code to change the filled
reader shrink pdf; change font size in pdf
CASE
STUDY
: EJB 
GENERATION
207
w
This block of XML defines the Book entity. The BookID field is the primary key for
the table. The fields of the table are title, ISBN, status, and numCopies. The
author of the book and the publisher are defined through relations to the Author and
Publisher tables through AuthorID and PublisherID.
e
The Author table is defined in this block of XML. It contains the primary key
field
AuthorID
, as well as fields that store the author’s name and pen name.
r
This XML block defines the Publisher table, which contains two fields: the Pub-
lisherID field, which is the primary key, and the name field, which stores the name
of thepublisher.
t
The foreign-key tag defines a relationship between two tables. In this case, we are
relating the Book table to the Author table through the AuthorID field.
y
This block relates the Book table to the Publisher table through the Publish-
erID field.
10.5.8
The extensions definition file
The basic schema and its entity objects are never enough to implement a production
system of any complexity. You also need custom queries and customized business logic.
The case study generator uses an extensions file:
<extensions>
<value-object name="BookWithNamesValue" base-table="Book">          
<add-column table="Author" column-name="name" />                     
<add-column table="Author" column-name="penName" />                  
<add-column table="Publisher" column-name="name" />                  
</value-object>                                                        
<sql-query-method name="getAllByTitle" value-object="BookWithNames
Value" >
<parameter name="title" java-type="String" />                        
<where>Book.title = ?</where>                                        
</sql-query-method>                                                    
<sql-query-method name="getAllByAuthorName" value-object= 
"BookWithNamesValue" 
<parameter name="authorName" java-type="String" />                
<where>Author.name = ?</where>                                       
</sql-query-method>                                                    
<finder-method name="findAllByPublisherID" table="Book">            
<parameter name="publisherID" java-type="java.lang.Integer" />       
<ejb-ql>SELECT OBJECT(o) FROM Book o WHERE o.publisherID = ?1</ejb-ql>   
</finder-method>                                                       
<custom-method name="updateStatusByPublisher" table="Book" 
returntype="void" >
<parameter name="publisherID" java-type="Integer" />             
<parameter name="newStatus" java-type="Integer" />                   
e
The getAllByAuthor-
Name definition
The BookWith-
NamesValue
value object
q
r
The findAllBy-
PublisherID
definition
The getAll-
ByTitle
definition
w
t
The update
StatusBy-
Publisher
method
208
CHAPTER 10
C
REATING
DATABASE
ACCESS
GENERATORS
<body>                                                               
BookEntityHome home = BookEntityBean.getHome();                    
Collection coll = home.findAllByPublisherID(publisherID);          
for(Iterator i = coll.iterator(); i.hasNext(); ){                  
BookEntity book = (BookEntity)i.next();                          
book.setStatus(newStatus);                                       
}
</body>                                                              
</custom-method>                                                       
</extensions>
q
The BookWithNamesValue object defines the fields that are returned from an SQL
query. There is a big efficiency improvement with this technique instead of using
Enterprise JavaBeans Query Language (EJB/QL). The BookWithNamesValue
structure is specified first by using the Book table as the base set of fields, then using
add-column tags to include additional fields that will be returned by the query.
w
The getAllByTitle query is defined by specifying the where tag that creates the
SQL where clause and the BookWithNamesValue object as the output. By using
the base-table attribute that is referred to by the value-object, the generator
can build the query and add the where clause to get the correct data from the database.
e
The getAllByAuthorName query is defined using a similar method. In this case,
the query gathers all of the authors that match a particular name.
r
The findAllByPublisherID query is an EJB finder that is specified by the
finder-method
tag. This query will find all of the books published by a particular
publisher. It is implemented using the EJB/QL functionality, which queries the local
object store instead of the database.
t
The updateStatusByPublisher query shows how you can implement custom
business logic in this generator. In this case, you are attaching the method to the Book
class. The return-type attribute tells the generator the return type of the method.
The parameter tags specify the arguments to the method and their types. The
body tag defines the Java for the method. It is important for the generator to under-
stand the input arguments and output type so that the generator can marshal the
method through the rest of the technology stack.
10.5.9
Sample data definition 
This case study EJB generator also builds Java code that will preload the database with
sample data through the EJB layer. The data is organized into rows that have a table
specification attached. Within each row are data elements organized into column tags.
Each column has a name that corresponds to the field in the row and a value, which is
the sample data value.
t
The update Status-
ByPublisher method
CASE
STUDY
: EJB 
GENERATION
209
Here is an example set of data:
<samples>
<row table="Author">                                                
<column name="authorID" value="100" />                            
<column name="name" value="Conway" />                             
</row>                                                              
<row table="Author">
<column name="authorID" value="101" />
<column name="name" value="Tate" />
</row>
<row table="Publisher">                                             
<column name="publisherID" value="100" />                         
<column name="name" value="Manning" />                            
</row>
<row table="Book">                                                  
<column name="bookID" value="100" />                              
<column name="title" value="Object Oriented Perl" />              
<column name="ISBN" value="1-884777-79-1" />                      
<column name="authorID" value="100" />                            
<column name="publisherID" value="100" />                         
<column name="status" value="3" />                                
<column name="numCopies" value="1" />                             
</row>
<row table="Book">
<column name="bookID" value="101" />
<column name="title" value="Bitter Java" />
<column name="ISBN" value="1-930110-43-X" />
<column name="authorID" value="101" />
<column name="publisherID" value="100" />
<column name="status" value="5" />
<column name="numCopies" value="1" />
</row>
</samples>
10.5.10 Implementation
The central ejbgen.rb file uses the functions defined in ejbgenRead.rb to read the XML
definition files. ejbgenRead.rb in turn creates classes that are defined in ejbgenDefs.rb.
Process flow returns to ejbgen.rb, which then invokes the templates that build the tar-
get output files. The templates access the data from the definition files by accessing the
classes defined in ejbgenDefs.rb. Figure 10.7 is a block diagram of the generator Ruby
code, broken into three files. Figure 10.8 shows a UML diagram that represents the
classes defined in the ejbgenDefs.rb file.
To learn more about this generator and its templates, see appendix C.
Sample 
book record
Sample 
author record
Sample 
publisher record
210
CHAPTER 10
C
REATING
DATABASE
ACCESS
GENERATORS
10.5.11 Performing system tests
The first set of system tests run against the generator uses the system test framework
described in appendix B. This system test runs the generator and stores the output files
as known goods. Then, at any time you can rerun the test and compare the current
output against the known goods to see if any changes have been made to the output.
The system test definition file is included on the book’s web site at www.codegenera-
tion.net/cgia.
ejbgen.rb
ejbgenRead.rb
ejbgenDefs.rb
Templates
Figure 10.7
The files of the EJBGen generator
Figure 10.8 8 A UML diagram for 
the EJBGen classes
CASE
STUDY
: EJB 
GENERATION
211
The second unit test is the sample data loader that uses the EJB entity classes
created during generation to load the data into the database. This data-loading test
is developed as a primary output of the generator. For more details, see the code in
appendix C.
This twofold approach to unit testing provides excellent coverage of the system.
First, the output of the generator is checked directly, and then the function of the out-
put code is checked.
You can also check the result through the web server using the test pages.
10.5.12
J2EE developer resources
If you want to become more familiar with J2EE and EJB, try some of the resources
listed here:
• The official Sun J2EE site (http://java.sun.com/j2ee/) is the source for Java devel-
opment kits as well as a resource for developer documentation.
• Sun’s J2EE Patterns page (http://developer.java.sun.com/developer/technicalArti-
cles/J2EE/patterns/) contains pragmatic advice on using J2EE in your enterprise
application. 
• The Server Side (www.theserverside.com) has articles and example code for devel-
opers building Java web applications. 
• JBoss (www.jboss.org) is the application server used in our case study. This site
has downloads and documentation for the application server.
• Tomcat (http://jakarta.apache.org/tomcat/index.html) is the web server and JSP
infrastructure used in the case study to serve the web pages.
• PostgreSQL (www.postgresql.com/) is the free database server used in the case study. 
• The official site for the JUnit testing framework is www.junit.org. 
• The Struts Model-View-Controller framework (http://jakarta.apache.org/struts/
index.html) is used for connection pooling in the case study. 
• Web Development with JavaServer Pages, 2nd Edition, by Duane K. Fields, Mark
A. Kolb, and Shawn Bayern (Manning, 2001), covers the JSP front-end portion
of the server stack. 
• Java Development with Ant, by Erik Hatcher and Steve Loughran (Manning,
2002), contains a section on generation with XDoclet.
• Enterprise JavaBeans, by Richard Monson-Haefel (O’Reilly, 2001), covers the EJB
architecture in depth. 
• SQL in a Nutshell, by Kevin Kline, with Daniel Kline (O’Reilly, 2002), discusses
using SQL for database access. 
• Java Enterprise in a Nutshell, by David Flanagan, Jim Farley, William Crawford,
and Kris Magnusson (O’Reilly, 2002), is a reference guide for the J2EE API.
Documents you may be interested
Documents you may be interested