Lecture notes

Martin Goik

Stuttgart Media University / MI

Table of Contents
Preface
Software development 1
Getting started
Lecture related resources
Using the exercises
Common software development related resources
Supervised tutorials
Tools of the trade, part 1
Play!
“Hello, World” and friends.
Simple calculations
A conditional
A loop
Tools of the trade, part 2
Maven command line usage
Maven and Intellij IDEA
Examination Maven Intellij IDEA import.
Maven and Eclipse
Language Fundamentals
Integer, ASCII and Unicode
Variables
Literals
Arithmetic limitations
Conversions
Operators and expressions
Comments
Statements
The if conditional statement
The switch statement
Loops
while
do ... while
for
Logic related external exercises
Objects and Classes
Working with objects
Packages
Object methods
Encapsulation and access control
Getter and setter methods
Signatures
Method overloading
Constructors
Static Members
A mathematical table.
Interest calculations
Lotteries revisited
The greatest common divisor and the common multiple
Cancelling fractions
Building a library of mathematical functions.
Value types and reference types
Method calls, the details
A unit testing example
Core Classes
Reconsidering System.out.format().
Using class Math
String exercises
Analyzing file pathnames
Arrays
java.util.Arrays helpers
Extending an array
Storing integer values
Understanding static public int main(String[] args)
Multi-dimensional arrays
Tic-tac-toe
Tic-tac-toe using a two-dimensional array
Changing the game's internal representation
Tic-tac-toe, Computer vs. human
Providing statistical data
Prime numbers revisited
A simple algorithm
Improving performance
The median of a given sample.
Plotting functions
Inheritance
Overriding toString()
final methods
Abstract methods
Geometry classes reconsidered
protected access
final classes
The instanceof operator
Error Handling
Checked vs unchecked exceptions
Exceptions and Junit
Variants
Class java.lang.Exception
Working with Numbers
Boxing and Unboxing
Number Parsing
Number Formatting
Working with Money
Generating Random Numbers
interface definitions and abstract Classes
A nonsense generator
An interface based plotter
Application deployment I (8.12.)
Preparations
Exercises
Part II, Exercises
Reading character streams
Preparations
Exercises
Collections
Preparations
Collections I, Exercises
A Set of Strings
A List of Strings
Defining a Coordinate class
A Set of Coordinate instances
Collections I, Exercises
Getting a Set of strings from a text file
Result string ordering
Sorting strings in an unusual way
Result string ordering
Collections III, Exercises
Collections IV, Exercises
Maps 1, Preparations
Exercises
Towns and country names
Creating an overview of grades
Appendix
Examination hints
Recommended external exercises
Examination bonus point projects
Reverse Polish notation (RPN) calculator
Currency converter, Summer 2017
An address database, Winter 2016
Poor man's UNIX grep, Summer 2016
Project Euler's sieve, Winter 2015
List of Exercises
Exercises in Getting started
Exercises in Language Fundamentals
Exercises in Statements
Exercises in Objects and Classes
Exercises in Core Classes
Exercises in Arrays
Exercises in Inheritance
Exercises in Error Handling
Exercises in Working with Numbers
Exercises in interface definitions and abstract Classes
Exercises in Application deployment I (8.12.)
Exercises in Reading character streams
Exercises in Collections
Structured Data and Applications 1
Prerequisites
Lecture related resources
Tools
JDK and IntelliJ IDEA
Oxygenxml standalone version
Mysql Database components
SQL client software
A relational recap exercise
Introduction to XML
The XML industry standard
Well formed XML documents
Beyond well- formedness
Motivation
XML Schema
Structural descriptions for documents
Element definitions
Attribute definitions
XPath and node sets
Uniqueness Constraints
Referencing constraints
Best practices
Dealing with <memo> documents
Relating schema's and SQL - DDL
The airline example revisited
Relating schema's and Java™ class descriptions.
XML schema exercises
DOM
Language independence
New document
Exercises
Parsing
Simple DOM processing
Visualizing XML document elements
Reminder to functional programming elements in Java™.
Creating HTML output
Cleaning up HTML.
Using DOM with HTML/Javascript
DOM and XPath
DOM and XSL
Namespace / elements statistics
Accessing Relational Data
Persistence in Object Oriented languages
Introduction to JDBC™
Write access, principles
Write access, coding!
JDBC™ and security
Read Access
Handling surrogate keys
Transactions
Getting started with JPA
Notes on tooling
A round trip working with objects
Mapping OO domain model to database model
Inserting objects
Retrieving objects
Updating objects
Querydsl
JPQL
Criteria queries
Querydsl
Enhancing the model
Persisting lecture instances
Exporting XML catalog data using JPA.
MongoDB
Prerequisites
Mongo Shell CRUD operations
Appendix
Examination amending projects
Marking criteria / Hints
Exporting and importing relational data
Project Docbook CMS.
Project business cards
Using Vaadin
Configuring Maven.
Properties, editors and listeners
A first GUI sketch
Input validation and error handling
Decoupling GUI and database components
User initiated connect to database.
A user authentication “strategy”
Passwords and hash values
Gui authentication: The real McCoy
Architectural security considerations
The Extensible Stylesheet Language XSL
Required knowledge
A “Hello, world” XSL example
Example: memo recipients
Some important XSL elements
A complete HTML formatting example
Transforming arbitrary XML to XHTML
XML APIs, the Simple API for XML (SAX)
Recommended reading
The principle of a SAX application
First steps
Event- and error handler registration
SAX validation
Namespaces
Print
online / print
Simple FO
Page layout
Header/footer
Important Objects
FO from XML
A catalog
List of Exercises
Exercises in Prerequisites
Exercises in Introduction to XML
Exercises in Beyond well- formedness
Exercises in The Document Object Model (DOM)
Exercises in Accessing Relational Data
Exercises in Getting started with JPA
Exercises in MongoDB
Technical Documentation
Software independent considerations
General remarks
Common building blocks
Block level elements
Docbook
Target formats
Selected elements
Schematron
Customizing
Assemblies
Styling the editor application
Modular documents
RelaxNG Schema
Transforming documents
Target format HTML
Target format print
Software
Frontends
Backends
TeX / LaTeX
Docbook
Exercises
LaTeX
LaTeX hello,... world
Important elements
Macro
A complete document
Docbook
Possible projects
Past projects
List of Exercises
Exercises in Software independent considerations
Exercises in Exercises
Structured Data and Applications 2
ldap and JDBC
Getting started with LDAP
Setting up an Openldap server
Adding some sample data using Apache Directory Studio
LDIF export and import
Searching the DIT
UNIX to SQL to LDAP
Transactions in JDBC™
Account Transfer using pessimistic concurrency control
Account Transfer using optimistic concurrency control
JPA
Configuring a Maven based Eclipse Java™ project with Hibernate
Create a Maven based project in Eclipse
Adding a Mysql™ JDBC™ driver
Adding Hibernate dependencies
Creating a JPA configuration
A round trip working with objects
Persisting objects
Loading Objects by primary key
Loading objects by queries
Criteria based queries
Mapping single entities and database tables
Transient properties
Properties and NULL values
Defining keys
Composed keys
Indexes (non-unique)
Renaming tables and attributes
Changing the default type mapping
Object states and transitions
XML to JPA using JAXB
Inheritance
Single table per class hierarchy
Joined subclasses
Table per concrete class
Mapping related Components and entities
Primary keys revisited
Entity and value types
Mapping components
Caching
orphanRemoval vs. CascadeType.DELETE
REST applications based on Java™-rs
List of Exercises
Exercises in ldap and JDBC
Exercises in JPA
Software defined infrastructure
UNIX / LINUX Basics
Prerequisites
Ubuntu / Debian Package management
Prerequisites
Getting started
Accessing your virtual machine
DNS
Preliminaries
Exercises
Installing Bind
Basic configuration
Forwarders
Mail exchange record
LDAP
Recommended Preparations
Exercises
Browse an existing LDAP Server
Set up an OpenLdap server
Populating your DIT.
Testing a bind operation as non - admin user
Accessing LDAP data by a mail client
LDAP configuration
Filter based search
Extending an existing entry
Backup and recovery / restore
Replication
LDAP based user login
Accessing LDAP by a Java™ application.
Apache web server
Preliminaries
Exercises
First Steps
Virtual hosts
SSL / TLS Support
LDAP authentication
Mysql™ database administration
Providing WEB based user management to your LDAP Server
Publish your documentation
Network file systems served by Samba
Prerequisites
Samba server installation
Mail
Recommended Preparations
Exercises
Install and send to local Users
Authentication Setup and Virtual Users
TLS
Spam and Virus defense
Systems surveillance
Working with Nagios
Persistence strategies and application development
Selected topics related to persistence in application development
Recommended reading
Getting started
Creating a Hibernate JPA project
Adding keys and AUTO_INCREMENT
Advocating simple key definitions
List of Exercises
Exercises in Selected topics related to persistence in application development
Bibliographic links
Glossary
List of Figures
1. Recommended reading resources
2. Online Java™ programming tutorial
3. Unix and the terminal
4. Online programming, automated feedback
5. Java Visualizer
6. Live lecture additions
7. Intellij IDEA IDE
8. Virtualbox™ image / native (dual boot) installation
9. Alternatives using Linux
10. Exercise features
11. Using the exercises
12. Programming projects in examinations
13. Download zipped Maven project
14. Select project archive
15. Locate archive and hit »Open With Archive Manager...«
16. Extract Exam folder
17. Folder to be imported in next step
18. Start project import
19. Select previously extracted Folder
20. Select Maven project model
21. Accept “Enable Auto-import”
22. Optional: Show packages
23. Execute complete test class
24. Results yet negative
25. Set breakpoint in method.
26. Debug individual test method
27. Step through hunting for errors
28. Show overall results
29. Hit Run 'ShowReachedPoints'
30. Your results so far
31. Zip up your project into an archive
32. Choose an archive name
33. Newly created archive
34. Hit »Choose File« in ILIAS
35. Hit »Upload«
36. Archive is visible ...
37. ... but not yet saved!
38. Confirm saving / next exercise
39. Answer saved!
40. Finish your examination
41. Check your answers again!
42. Proceed finishing ...
43. Finish the test
44. The codingbat sleepIn example.
45. Cash register
46. Zuse Z3
47. Eniac
48. Microprocessor ICs
49. Zilog Z80 CPU
50. Address and data bus sizes
51. Signed 3 bit integer representation
52. Signed 8 bit integer binary representation
53. 7-bit ASCII
54. 7-bit ASCII with even parity bit
55. ISO Latin 1 encoding
56. Some Unicode UTF-8 samples
57. Handle to memory
58. Variable declaration
59. Declare and use
60. Declaration and initialization
61. Multiple variables of same type
62. Variable naming conventions
63. Constants
64. Variable names (identifier)
65. Java™ keywords.
66. Case sensitivity
67. Define before use
68. Type safety
69. Compile time analysis
70. Forcing conversions
71. Watch out!
72. C: Don't worry, be happy ...
73. ... and watch the outcome
74. From the report
75. Maximum and minimum values
76. Dynamic typing in PERL
77. Using final
78. Two categories of variables
79. Reference type examples
80. float and double
81. Four ways representing 35
82. Know your limits!
83. Literal examples
84. int literals
85. int literals explained
86. Java™ literals
87. Just kidding ...
88. Strange things
89. Overflow
90. Limited precision
91. FloatConverter
92. Widening from byte to short
93. Narrowing from int to char
94. The binary plus operator
95. Binary operator output type
96. Arithmetic overflow pitfalls
97. Detecting arithmetic overflow (Java 8+)
98. Dividing by zero
99. Operator type behaviour
100. Binary operator type examples
101. Operator examples
102. Two comment flavors
103. “Inline” comments
104. Purposes of statements
105. General Syntax
106. Example: Declaring and assigning variables
107. Expression vs. statement
108. Multiple statements per line
109. Debugging multiple statements per line
110. Blocks
111. if block execution selection
112. if execution syntax
113. if ... else block execution selection
114. if ... else execution syntax
115. Best practices comparing for equality
116. Single statement branches
117. Corporate network security
118. Online banking
119. IP Spoofing
120. SSL Certificate error
121. The Apple “goto fail” SSL bug
122. Static code analysis
123. Nested if ... else
124. if ... else if ... else
125. if ... else if ... else syntax
126. User input recipe
127. Using a Scanner class collecting user input.
128. Converting numbers to day's names
129. Implementing day's number to name
130. Better: Using switch
131. switch Syntax
132. Switching on strings
133. Why loops?
134. Hard to parameterize
135. A while loop
136. Combining increment and termination condition
137. while syntax
138. Empty while body
139. A do ... while loop
140. do ... while syntax
141. Frequent usage of while
142. Replacing while by for
143. for syntax
144. for variable scope
145. for variable scope equivalence
146. for vs. while relationship
147. Nested loops
148. Calculating values
149. Instances of a Class
150. General class structure
151. What's a class anyway?
152. Rectangle objects
153. A class describing rectangles
154. Rectangle class and instances
155. Generated diagrams
156. Creating rectangle instances
157. Syntax creating instances
158. Assigning attribute values
159. Memory representation
160. References and null
161. References and null
162. Packages
163. Rules and conventions
164. Qualified name vs. import
165. Don't be too lazy!
166. Classes from java.lang
167. Class, package and file system
168. Source hierarchy view
169. Object methods
170. Scaling a rectangle
171. Scaling implementation
172. Using scale(...)
173. Method definition syntax
174. A rectangle's perimeter
175. Get perimeter implementation
176. Using Rectangle.getPerimeter()
177. Access control: Overall objectives
178. Example: Implementing time and date
179. Access violation
180. Access rules
181. “Tips on Choosing an Access Level”
182. Direct access vs. setter method
183. Why adding setter methods?
184. Implementation by minutes only
185. Package hierarchy of the employee example
186. Type signatures
187. Defining type signatures
188. A method signature
189. What is overloading?
190. Overloading, alternate names
191. No such concept in C
192. What about return type?
193. Method signatures rationale
194. Method signatures rationale
195. Example: System.out.print(...)
196. Creating and initializing rectangles
197. Defining a constructor
198. Constructor syntax
199. Constructors
200. Multiple constructors by overloading
201. Instances by overloaded constructors
202. No constructor vs. default constructor
203. Absent default constructor
204. Club membership objectives
205. Implementing membership numbers.
206. Showing membership numbers.
207. Access to the club's overall member count?
208. Accessing the club's member count
209. Do we require an instance?
210. Favour class over instance method
211. Syntax accessing class members
212. Defining a dependency to another Maven artifact.
213. Pascal's triangle representing binomial coefficients.
214. An implementation sketch for the exponential
215. Comparing exponential and approximation
216. Comparing sin(x) and its approximation.
217. Value vs. reference types
218. Example
219. Value variable Details
220. Reference variable Details
221. Only »call-by-value« in Java™
222. »call-by-value« details
223. »call-by-reference« for objects?
224. »call-by-reference« details
225. No »call-by-reference« in Java™
226. No »call-by-reference« details
227. C++ offers “true” »call-by-reference«
228. C++ »call-by-reference« details
229. Method calling
230. Three variable scopes
231. Scope lifetimes
232. Two runtime memory categories
233. Stack: Four operations
234. Example: Storing integer values
235. Method calling
236. Call stack trace
237. IDE debugger
238. Informal problem specification
239. Illustrating examples
240. Javadoc™ method specification
241. Execution using main(...)
242. Junit based specification test
243. Unit test execution
244. Execution result
245. More tests
246. Mass test examples
247. Observations
248. Correcting the implementation
249. Execution result
250. “Final” implementation
251. Execution result
252. Available comparison methods
253. Maven command line usage
254. Caution comparing float / double
255. Weird arithmetics?
256. Limited representation precision
257. Solving the issue
258. Superclass Object
259. String literals
260. OpenJDK String implementation
261. String copy constructor
262. Copy constructor and heap
263. Operator == and equals()
264. Hashing principle
265. Rectangle equals(...) and hashCode()
266. Rectangle hash values
267. Rectangle equals(...) and hashCode()
268. Contract equals(...) and hashCode()
269. Motivating Arrays
270. Per member repeating tasks
271. Example: int array of primes
272. Loop prime values
273. Mind the limit!
274. Safer: Using length
275. Safer: Use “for-each” style loop
276. Mind the limit, part two
277. One step initialization
278. Array
279. Two syntax variants
280. Array instances are special!
281. Array creation details
282. Array parameter passing
283. Parameter passing details
284. Value and reference types
285. Arrays.toString(...) and Arrays.sort(...)
286. Arrays.binarySearch(...)
287. Arrays.fill(...)
288. Arrays.copyOfRange(...)
289. Arrays.equals(...)
290. Extension problem
291. Extending an array
292. Extension result
293. Using Arrays.copyOf()
294. public static void main(String[] args)
295. Intellij IDEA run configuration
296. Intellij IDEA run configuration
297. Creating executable jar
298. Multidimensional arrays
299. Behind the scenes
300. Memory allocation
301. Two Tic-tac-toe players fighting each other.
302. Two Tic-tac-toe players fighting each other.
303. Duplicate code
304. Common and specific properties
305. Basic shape inheritance
306. Inheritance
307. Implementing Shape hierarchy
308. Creating instances
309. Shape constructor
310. Shape log info
311. Overwriting toString()
312. Shape extending Object
313. Creating Rectangle instances
314. Rectangle constructor
315. Logging Rectangle instances
316. Override toString() again.
317. Rectangle extending Shape´
318. Implementing Circle
319. Shape and toString()
320. Moving Shape instances
321. Implementing Shape movements
322. Fools are everywhere!
323. Solution: final prevents overriding
324. Calculating a shape's area
325. Desired: Polymorphic getArea() call
326. Problems:
327. abstract method getArea()
328. abstract method getArea()
329. What's a “shape” anyway?
330. No instances of abstract classes.
331. Mandatory getArea() implementation.
332. Facts about abstract fields, methods and classes.
333. Moving shapes
334. protected access
335. final classes
336. final classes, rationale
337. “Defeating” polymorphism
338. Defining equals(...) of Shape instances
339. Comparing center coordinates
340. Implementing Rectangle.equals()
341. Implementing Circle.equals()
342. Testing equality of Shape objects
343. Compile- and runtime errors
344. NullPointerException (NPE for short)
345. NullPointerException is a class
346. Throwing an exception
347. Catching an exception by try {...} catch {...}
348. try {...} catch {...} syntax
349. Checked and unchecked exceptions
350. Checked and unchecked exceptions
351. Expected exceptions in Junit
352. Just finally
353. try-with-resources (Java™ 7)
354. Method printStackTrace()
355. Ascending inheritance ordering
356. Descending inheritance ordering
357. Implementing convert
358. Problem: “Silent” errors
359. Step 1: Find exception base class
360. Step 2: Derive CardinalException
361. Step 3: Throwing CardinalException
362. Step 4: Unit test throwing CardinalException
363. Stack of integer values
364. Java™ collection features
365. Behind the scenes
366. Boxing and unboxing
367. Boxing syntax comparison
368. Parsing Integer user input
369. Parsing binary representation
370. Standard parse methods
371. Excerpt from java.util.Locale
372. Locale properties
373. Get a NumberFormat instance
374. Create a custom formatter
375. Polymorphic number parsing
376. Limited float precision
377. Limited double precision
378. Using BigDecimal
379. BigDecimal features
380. Using static double random​()
381. Seeding a pseudo random generator
382. Interface examples
383. Observations
384. Writing strings to file
385. Using Text2File
386. Possible Text2File errors:
387. Employ “try-with-resources”
388. interface syntax
389. The AutoCloseable promise
390. abstract class replacement
391. interface vs. abstract class
392. interface MyAutoCloseable
393. Extending MyAutoCloseable
394. Using MyFlushable
395. Inheritance hierarchy
396. Upcoming topics
397. What's the use of hashing anyway?
398. Account hierarchy
399. Students and lecturers
400. An array of strings
401. An associative array describing month lengths
402. Grouping towns by country names
403. Unit tests in examinations
404. Example interface definition
405. Corresponding test
406. Unit tests strategy in examinations
407. Bonus points
408. Collaborative efforts
409. Project rules
410. Internal code documentation
411. Internal code documentation hints
412. Javadoc™ mismatches
413. (Automated) tests
414. Deployment and execution
415. Marking criteria
416. Minimalist token scanner
417. Scanner output -1.34 0.34 + sqrt
418. Adding error detection
419. Error message
420. Running the currency converter terminal application.
421. Recommended reading
422. What is XML?
423. Application domains
424. Benefits
425. Relevance (2018/02)
426. JSON catches up!
427. Rendering (X)HTML markup
428. HTML tree structure
429. MathML formula
430. MathML tree graph representation
431. HTML / MathML document similarities
432. XML files: Representing data
433. Representing CAD data
434. XML basic structure
435. Minimal XML document
436. Empty tags
437. Representing messages.
438. MI department CLI parser
439. Non-wellformed, missing </from>
440. Parsing non-wellformed
441. Improperly nested elements
442. Improperly nested elements: Result
443. Proper nesting of XML elements
444. Improperly nested elements
445. date and priority attributes.
446. Unique attribute names
447. Quotes required
448. Important well-formedness constraints
449. XML markup collision I
450. XML markup collision II
451. XML standard replacement entities
452. Using CDATA sections
453. Using replacement entities
454. Processing instruction (PI)
455. Recommended reading
456. XML and application code
457. HTML validity
458. Well-formed and valid
459. XML grammar examples
460. A <contact> record
461. <contact> business rules:
462. <contact> EBNF grammar
463. Initial organizer schema
464. Linking instance to schema
465. Centralized schema definition
466. Validating a contact
467. Uups, we fail!
468. Schema observations
469. Well-formed and valid documents
470. Terminology
471. V02: Define <email> as optional
472. V03: Multiple contacts
473. Choose <contact> as root
474. Graphical schema representation
475. Adding <birthDate>
476. Supply a <birthDate> type
477. Why <birthDate> element?
478. Using a birthDate attribute
479. Absent birthDate attribute
480. XSD attributes revisited
481. Consider <email>
482. User defined email type
483. Using new email type
484. Strange: The Ur type
485. Adding missing data types
486. Nested elements becoming invalid
487. Introducing categories
488. Category type violation
489. Ooops: Text content and attributes
490. SQL query result
491. Comparing SQL and XPath
492. Similarities and differences
493. Simple XPath queries
494. Relative file system search using find
495. find starting from absolute path
496. XPath and context nodes
497. Union
498. Union / descent
499. Recursive search for element name
500. Recursive + index search
501. Surprise!
502. Siblings
503. Following siblings
504. Disjoint XPath axis definitions.
505. Element restricted following siblings
506. Elements containing non-whitespace text
507. Elements containing text containing 'house'
508. Elements containing text of minimal length
509. Searching for attribute presence
510. Searching for attribute value
511. Introducing nicknames
512. Nickname semantics
513. <xs:unique>
514. Introducing id values
515. id semantics
516. <xs:key> vs. <xs:unique>
517. Enhancing error message understanding
518. Referencing contacts
519. Violating referential integrity
520. Enforcing referential integrity
521. Participant reference duplicates
522. Solution:New key constraint
523. Participant reference duplicates
524. Nested vs. reference
525. <memo> exercise series
526. Invoice integrity constraints
527. Relational implementation
528. XML schema's and Java™ class declarations.
529. A first schema version for book documents
530. Version 2 of book.xsd
531. Required knowledge
532. Important XML Java™ APIs
533. SAX: XML to events
534. SAX architecture
535. DOM assembly
536. SAX deficiencies
537. DOM: Language independence
538. DOM: Vendor independence
539. DOM Node CORBA 2.2 IDL
540. Defining a language binding
541. org.w3c.dom.Node Java™ binding.
542. A context node's children
543. org.w3c.dom.Node subtypes
544. DOM Java™ binding inheritance interface hierarchy
545. DOM modules.
546. Jdom vs. DOM: Advantages
547. Jdom vs. DOM: Disadvantages
548. Prerequisite: pom.xml configuration
549. Exporting data as XML
550. XML document creation from scratch.
551. XML catalog sample data
552. SAX error handler
553. Accessing an XML Tree purely by DOM methods.
554. Driver class execution entry point
555. Project sample code for import
556. DOM and Javascript
557. DOM Javascript example
558. DOM Javascript demo
559. Why using XPath ?
560. XPath and Jdom
561. HTML containing <img> tags.
562. Objective: Find contained images
563. XSL script extracting images.
564. Setting up the parser
565. Search using XPath //html:img
566. Searching for images
567. Parameterized search expressions
568. A simplified XML product catalog
569. A XSL style sheet for catalog transformation to HTML.
570. Transforming an XML document instance to HTML by a XSL style sheet.
571. A driver class for the xml2xml transformer.
572. Prerequisite knowledge
573. Persistence [Bauer2015]
574. Java™ transient instances
575. RDBMS persistent records
576. Persisting transient User instances
577. Observations
578. Networking between clients and database server
579. JDBC™ features
580. JDBC™ in a three-tier application
581. JDBC™ connecting application server and database.
582. JDBC™ connection parameter
583. Components of a JDBC™ URL
584. IETF Uniform Resource Identifier
585. URL examples
586. Sub protocol examples
587. No standard port assignments ...
588. ... but Mysql made it into Linux
589. JDBC™ architecture
590. DriverManager: Bootstrapping connections
591. Example: Mysql connection implementation
592. Driver libraries
593. Driver libraries, Maven
594. Driver unavailable
595. Connection interface
596. Statement interface
597. JDBC™ instances and relationships.
598. Important Connection methods
599. Important Statement methods
600. JDBC™ and threading.
601. JDBC™ connection pooling
602. pom.xml driver runtime scope
603. Person table
604. Objective: insert person record
605. JDBC™ backed data insert
606. Result
607. Two JDBC™ configurations
608. Figure 605, “JDBC™ backed data insert ” deficiencies
609. Why properties?
610. message.properties string externalization
611. Properties code sketch
612. Intellij IDEA settings, preconditions
613. Database related unit test phases
614. Implementing unit tests
615. Spring is your friend
616. Project layout
617. Closing connections
618. Employ AutoCloseable
619. Sniffing a JDBC™ connection by an intruder.
620. Setting up Wireshark
621. Capturing results
622. Mysql™ security
623. Mysql™ security
624. Assembling SQL
625. SQL injection principle
626. Trouble at school
627. SQL injection impact
628. SQL injection relevance, [Clarke2009]
629. Lessons learned?
630. Validating user input prior to dynamically composing SQL statements.
631. Error message being presented to the user.
632. SQL statements in Java™ applications get parsed at the database server
633. Two questions
634. Addressing performance
635. Addressing performance mitigation
636. Addressing security
637. Solution: Use java.sql.PreparedStatement
638. PreparedStatement principle.
639. Three phases using parameterized queries
640. PreparedStatement example
641. Injection attempt example
642. No dynamic table support
643. JDBC™ read and write
644. Server / client object's life cycle
645. JDBC™ record container
646. Reading data from a database server.
647. Names and birth dates of friends
648. Accessing friend's database records
649. Important ResultSet states
650. JDBC™ to Java™ type conversions
651. Java™ to JDBC™ type conversions
652. Fixed type accessors
653. Polymorphic accessors
654. Access by column name
655. Access by column index
656. Problem: null value ambiguity
657. Resolving null value ambiguity
658. Users and groups
659. Isolation level
660. JDBC™ Isolation level
661. Setting the isolation level
662. Why using JPA ?
663. What about “impedance”?
664. OR impedance mismatch
665. JPA 2.0
666. JPA 2.1
667. JPA 2.2
668. JPA overview
669. JPA components
670. Maven pom.xml
671. Right click »Add Framework Support«
672. Enable Hibernate support
673. »File« --> »Project Structure«
674. Criteria / Querydsl annotation processing
675. Class StudyCourse
676. Transient instance
677. Persistence: Business rules
678. StudyCourse entity definition
679. persistence.xml configuration
680. CreateStudyCourse using a transaction
681. Database state
682. ReadStudyCourseById retrieval by primary key
683. Retrieving all instances
684. Type conversion problems
685. Reading shortName values
686. Adding a setter
687. Update language
688. Populating the database
689. JPQL: Domain model and database
690. JPA query alternatives
691. JPQL
692. JPQL parameter
693. JPQL record retrieval
694. Criteria entity metamodel
695. Criteria query
696. No injection susceptibility
697. Querydsl entity metamodel
698. From “Querying JPA”
699. Querydsl query
700. No injection susceptibility
701. Business and surrogate keys
702. Database generation strategies
703. INSERT omitting id
704. Generated surrogate id
705. StudyCourse creation
706. Entity Student
707. Database schema
708. Providing enrollment
709. CreateUniversity
710. Editing a Docbok 5 document using the XMLMind editor.
711. A simple GUI to insert data into a database server.
712. PersistenceHandler state transitions.
713. A GUI frontend for adding personal data to a server.
714. Login credentials for database connection
715. Intended usage behaviour for insertion of data records.
716. XSL target formats
717. Motivating XSL
718. A memo document instance with an internal reference.
719. Extracting the sender's name
720. Execution and Result
721. XSL processor transforming XML using a stylesheet
722. Transformation syntax details
723. List of recipient nodes iteration.
724. Selecting node sets from memo document instances
725. XPath content/para starting from context node <memo>.
726. Exporting SQL statements.
727. A graphical representation of our <catalog>.
728. A memo with 9 recipients
729. A <book> document with two chapters
730. Visualizing arbitrary XML input data.
731. Generating HTML from a XML document and an RDBMS.
732. A XML based catalog.
733. A Relation containing price information.
734. HTML generated output.
735. Parsing a XML document creates a corresponding sequence of events.
736. SAX Principle
737. Counting XML elements.
738. A non well formed document.
739. An invalid XML document.
740. A sample catalog containing products and corresponding descriptions.
741. The most simple FO document
742. Regions being defined in a page.
743. A complete FO parameterizing of a physical page and the fo:region-body.
744. Parameterizing page- and region view port. All length dimensions are in mm.
745. Parameterizing header and footer.
746. A fo:block with a fo:inline descendant.
747. An itemized list and result.
748. Two simulated entries in a table of contents.
749. Four entries separated by equal amounts of dotted space.
750. A horizontal line separator between header and body of a page.
751. Roman style page numbers.
752. A dictionary with running page headers.
753. Two blocks mutual page referencing each other.
754. Two blocks with mutual page- and hypertext references.
755. Different target formats from common source.
756. Generating a sender's surname for printing.
757. A memo document instance.
758. Why XML based publishing?
759. XML features
760. Editors, compositors, designers ...
761. Promises in publishing
762. Publishing reality
763. Single source publishing
764. Separating Structure, content and format
765. Separating concerns
766. Content
767. Hierarchical structure
768. Hierarchical structure, XML source
769. Presentation
770. Example 1: HTML 5, pure structure
771. Example 2: TeX / LaTeX
772. Separating structure and presentation(s)
773. Sample technical document
774. Observations
775. Pros and cons of TeX / LaTeX
776. Tools of the trade
777. Inline formatting
778. Paragraphs
779. Lists
780. Tables
781. Images
782. Mathematical formulas
783. Cross references
784. Document sectioning
785. Modular document components
786. What is Docbook?
787. Authoring and publishing
788. Document representation
789. Software centric schema
790. Document targets
791. Docbook components
792. Target format overview
793. Tooling / Software
794. Different schema languages
795. Plain HTML
796. Web help
797. Eclipse help
798. Printed output
799. Paragraph
800. Itemized list
801. Ordered list
802. Glossary list
803. Nested lists
804. Reference
805. A table
806. A MathML equation
807. A TeX equation
808. Reference
809. Figure
810. Image map + calloutlist
811. Video
812. A warning
813. Reference
814. Recursive sections
815. Non-recursive sections
816. Two different link flavours
817. Choosing a top level element
818. Allowed 5.1 top level elements
819. Schematron on top of RelaxNG
820. Example: xml:id and permalink
821. Using Display #Anchors
822. Considerations author based permalink
823. Schematron permalink rule
824. HTML customization overview
825. Target specific configuration
826. Link stability
827. use.id.as.filename = 1
828. Parameter: use.id.as.filename
829. Customization parameter ulink.target
830. callout.unicode / callout.graphics
831. Links
832. Hooking into XSL
833. Categories
834. Example: videos
835. Links
836. Customize by CSS
837. Example CSS modifications
838. Styling the editor
839. Motivating modular documents
840. Monolithic document problems
841. Document decomposition
842. A monolithic document
843. Decomposing documents
844. XML grammar defining languages
845. Address list schema
846. Format conversion problem
847. XSL template rules
848. Example: Formatting <title> elements
849. Basic FO introduction
850. XMLMind Editor
851. Oxygenxml Author
852. Vendor links
853. Inverse editing
854. Document representation
855. Components
856. BibTeX
857. Makeindex example
858. Makeindex work flow
859. Extension example: MusiXTeX
860. Flavours
861. Components
862. Editors
863. Two departments billing and research populated with sample user entries
864. Optimistic concurrency control
865. Failure with optimistic transactions
866. Reasons for using Maven
867. Transitive dependencies
868. A basic persistence.xml JPA configuration file.
869. JPA persistence provider
870. Mapping hibintro.v1.model.User instances to a database.
871. A basic User class.
872. Mapping properties to attributes.
873. Annotating integrity constraints
874. Database schema mapping instances of hibintro.v1.model.User.
875. Loading a single object by a primary key value.
876. Retrieving hibintro.v1.model.User instances by HQL.
877. Business rules for projects
878. Persistence related object states
879. Introducing inheritance mapping
880. Modelling payment.
881. A single relation mapping.
882. Mapping the inheritance hierarchy.
883. Inserting payment information
884. Figure subclasses
885. Joined subclass mapping.
886. Implementing Object.equals(Object) by natural keys
887. JPA caches.
888. Basics on Jax-RS
889. An example LDAP Tree
List of Tables
1. 4 Byte Two's complement representation of int values.
2. Exercises in
3. The Person table
4. Mapping elements from book.xsd to Xhtml
5. Exercises in
6. Exercises in
7. Exercises in
8. Exercises in
List of Equations
1. Calculating binomials by cancelling common factors.
1. Power series definition of f ⁡ x = e x
2. Power series definition of f ⁡ x = sin ⁡ ( x )
3. Reordering of terms with respect to an implementation.
4. Power series definition of cos ⁡ ( x )
     Next