HANDS-ON MACHINE LEARNING WITH SCIKIT-LEARN, KERAS, AND TENSORFLOW: CONCEPTS, TOOLS, AND TECHNIQUES TO BUILD INTELLIGENT SYSTEMS, SECOND EDITION (4-COLOUR EDITION)
NRS 3960.00
Book details / order
HEAD FIRST SERVLETS AND JSP, 2ND EDITION PASSING THE SUN CERTIFIED WEB COMPONENT DEVELOPER EXAM
Looking to study up for the new j2ee 1.5 sun certified web component developer (scwcd) exam?
this book will get you way up to speed on the technology you'll know it so well, in fact, that you can pass the brand new j2ee 1.5 exam. if that's what you want to do, that is. maybe you don't care about the exam, but need to use servlets and jsps in your next project. you're working on a deadline. you're over the legal limit for caffeine. you can't waste your time with a book that makes sense only after you're an expert (or worse, one that puts you to sleep).
learn how to write servlets and jsps, what makes a web container tick (and what ticks it off), how to use jsp's expression language (el for short), and how to write deployment descriptors for your web applications. master the c:out tag, and get a handle on exactly what's changed since the older j2ee 1.4 exam. you don't just pass the new j2ee 1.5 scwcd exam, you'll understand this stuff and put it to work immediately.
head first servlets and jsp doesn't just give you a bunch of facts to memorize; it drives knowledge straight into your brain. you'll interact with servlets and jsps in ways that help you learn quickly and deeply. and when you're through with the book, you can take a brand-new mock exam, created specifically to simulate the real test-taking experience.
about the authors
bryan basham is a sun certified developer for java 2 platform and one of the key designers of the sun certified web component developer exam. he is also a course developer for sun microsystems concentrating on java technology and object-oriented design principles. bryan has worked on a large range of java courses, including sun's core java programming course, the jdbc course, a j2ee overview seminar, the servlet/jsp course, and the oo analysis and design course.
kathy sierra has been interested in learning theory since her days as a game developer (virgin, mgm, amblin'). more recently, she's been a master trainer for sun microsystems, teaching sun's java instructors how to teach the latest technologies to customers, and a lead developer of several sun certification exams. along with her partner bert bates, kathy created the head first series. she's also the original founder of the software development/jolt productivity award-winning javaranch.com, the largest (and friendliest) all-volunteer java community.
bert bates is a 20-year software developer, a java instructor, and a co-developer of sun's upcoming ejb exam (sun certified business component developer). his background features a long stint in artificial intelligence, with clients like the weather channel, a&e;network, rockwell, and timken.
chapter 1 intro and overview: why use servlets & jsps?
everybody wants a web site
what does your web server do?
what does a web client do?
clients and servers know html and http
two-minute html guide
what you write... (the html)
what the browser creates...
what is the http protocol?
html is part of the http response
if that’s the response, what’s in the request?
get is a simple request, post can send user data
it’s true... you can send a little data with http get
anatomy of an http get request
anatomy of an http post request
anatomy of an http response, and what the heck is a “mime type”?
all the pieces. on one page.
url. whatever you do, don’t pronounce it “earl”.
directory structure for a simple apache web site
web servers love serving static web pages
but sometimes you need more than just the web server
two things the web server alone won’t do
the non-java term for a web server helper app is “cgi” program
servlets demystified (write, deploy, run)
jsp is what happened when somebody introduced java to html
chapter 2 high-level overview: web app architecture
what is a container?
what if you had java, but no servlets or containers?
what does the container give you?
how the container handles a request
how it looks in code (what makes a servlet a servlet)
you’re wondering how the container found the servlet...
a servlet can have three names
using the deployment descriptor to map urls to servlets
but wait! there’s more you can do with the dd
story: bob builds a matchmaking site
he starts to build a bunch of servlets... one for each page
but then it gets ugly, so he adds jsps
but then his friend says, “you are using mvc, right?”
the model-view-controller (mvc) design pattern fixes this
applying the mvc pattern to the matchmaking web app
but then his friend kim takes a look
is there an answer?
a “working” deployment descriptor (dd)
how j2ee fits into all this
chapter 3 hands-on mvc: mini mvc tutorial
let’s build a real (small) web application
the user’s view of the web application—a beer advisor
here’s the architecture...
creating your development environment
creating the deployment environment
our roadmap for building the app
the html for the initial form page
deploying and testing the opening page
mapping the logical name to a servlet class file
the first version of the controller servlet
compiling, deploying, and testing the controller servlet
building and testing the model class
enhancing the servlet to call the model, so that we can get real advice...
servlet version two code
key steps for servlet version two
review the partially completed, mvc beer advice web application
create the jsp “view” that gives the advice
enhancing the servlet to “call” the jsp (version three)
code for servlet version three
compile, deploy, and test the final app!
there is still so much to learn.
chapter 4 request and response: being a servlet
servlets are controlled by the container
but there’s more to a servlet’s life
the three big lifecycle moments
each request runs in a separate thread!
in the beginning: loading and initializing
the http request method determines whether doget() or dopost() runs
actually, one or more of the other http methods might make a (brief) appearance on the exam...
the difference between get and post
no, it’s not just about the size
the story of the non-idempotent request
post is not idempotent
what determines whether the browser sends a get or post request?
post is not the default!
sending and using a single parameter
sending and using two parameters
besides parameters, what else can i get from a request object?
review: servlet lifecycle and api
review: http and httpservletrequest
so that’s the request... now let’s see the response
using the response for i/o
imagine you want to send a jar to the client...
servlet code to download the jar
whoa. what’s the deal with content type?
you’ve got two choices for output: characters or bytes
you can set response headers, you can add response headers
but sometimes you just don’t want to deal with the response yourself...
servlet redirect makes the browser do the work
a request dispatch does the work on the server side
redirect vs. request dispatch
review: httpservletresponse
coffee cram: mock exam chapter 4
coffee cram: chapter 4 answers
chapter 5 attributes and listeners: being a web app
kim wants to configure his email address in the dd, not hard-code it inside the servlet class
init parameters to the rescue
you can’t use servlet init parameters until the servlet is initialized
the servlet init parameters are read only once—when the container initializes the servlet
testing your servletconfig
how can a jsp get servlet init parameters?
setting a request attribute works... but only for the jsp to which you forwarded the request
context init parameters to the rescue
remember the difference between servlet init parameters and context init parameters
servletconfig is one per servlet servletcontext is one per web app
so what else can you do with your servletcontext?
what if you want an app init parameter that’s a database datasource?
what, exactly, is an attribute?
coffee cram: mock exam chapter 5
coffee cram: chapter 5 answers
chapter 6 session management: conversational state
kim wants to keep client-specific state across multiple requests
it’s supposed to work like a real conversation...
how can he track the client’s answers?
how sessions work
one problem... how does the container know who the client is?
the client needs a unique session id
how do the client and container exchange session id info?
the best part: the container does virtually all the cookie work!
what if i want to know whether the session already existed or was just created?
what if i want only a pre-existing session?
you can do sessions even if the client doesn’t accept cookies, but you have to do a little more work...
don’t forget about httpsessionbindinglistener
httpsessionactivationlistener lets attributes prepare for the big move...
session-related listeners
coffee cram: mock exam chapter 6
coffee cram: chapter 6 answers
chapter 7 using jsp: being a jsp
in the end, a jsp is just a servlet
making a jsp that displays how many times it’s been accessed
she deploys and tests it
the jsp doesn’t recognize the counter class
use the page directive to import packages
but then kim mentions “expressions”
expressions become the argument to an out.print()
kim drops the final bombshell...
declaring a variable in a scriptlet
what really happens to your jsp code?
we need another jsp element...
jsp declarations
time to see the real generated servlet
the out variable isn’t the only implicit object...
a comment...
api for the generated servlet
lifecycle of a jsp
translation and compilation happens only once
initializing your jsp
attributes in a jsp
using pagecontext for attributes
examples using pagecontext to get and set attributes
while we’re on the subject... let’s talk more about the three directives
scriptlets considered harmful?
there didn’t used to be an alternative.
el: the answer to, well, everything.
sneak peek at el
using
you can choose to ignore el
but wait... there’s still another jsp element we haven’t seen: actions
coffee cram: mock exam chapter 7
coffee cram: chapter 7 answers
chapter 8 scriptless jsp: script-free pages
our mvc app depends on attributes
but what if the attribute is not a string, but an instance of person?
we need more code to get the person’s name
person is a javabean, so we’ll use the bean-related standard actions
deconstructing and can also create a bean!
you can use can have a body!
generated servlet when has a body
can you make polymorphic bean references?
adding a type attribute to
using type without class
the scope attribute defaults to “page”
going straight from the request to the jsp without going through a servlet...
the param attribute to the rescue
but wait ! it gets even better...
if you can stand it, it gets even better...
bean tags convert primitive properties automatically
but what if the property is something other than a string or primitive?
trying to display the property of the property
expression language (el) saves the day!
deconstructing the jsp expression language (el)
using the dot (.) operator to access properties and map values
the [] operator is like the dot only way better
the [] gives you more options...
using the [] operator with an array
a string index is coerced to an int for arrays and lists
for beans and maps you can use either operator
if it’s not a string literal, it’s evaluated
you can use nested expressions inside the brackets
you can’t do ${foo.1}
el renders raw text, including html
the el implicit objects
request parameters in el
what if you want more information from the request?
the requestscope is not the request object
scope implicit objects can save you
getting cookies and init params
imagine you want your jsp to roll dice
deploying an app with static functions
and a few other el operators...
el handles null values gracefully
jsp expression language (el) review
reusable template pieces
the include directive
the standard action
they’re not the same underneath...
the include directive happens at translation time happens at runtime
the include directive at first request
the standard action at first request
uh-oh. she’s right...
the way we should have done it
customizing the included content with
the standard action
a conditional forward...
how it runs...
with , the buffer is cleared before the forward
bean-related standard action review
the include review
coffee cram: mock exam chapter 8
coffee cram: chapter 8 answers
chapter 9 using jstl: custom tags are powerful
el and standard actions are limited
the case of the disappearing html (reprised)
there’s a better way: use the tag
null values are rendered as blank text
set a default value with the default attribute
looping without scripting
deconstructing
you can even nest tags
doing a conditional include with
but what if you need an else?
the tag won’t work for this
the tag and its partners and
the tag... so much cooler than
using with beans and maps
key points and gotchas with just makes sense
with , there are now three ways to include content
can reach outside the web app
customizing the thing you include
doing the same thing with for all your hyperlink needs
what if the url needs encoding?
you do not want your clients to see this:
make your own error pages
configuring error pages in the dd
error pages get an extra object: exception
the tag. like try/catch...sort of
you can make the exception an attribute
what if you need a tag that’s not in jstl?
using a tag library that’s not from the jstl
making sense of the tld
using the custom “advice” tag
the custom tag handler
pay attention to is not just for el expressions
what can be in a tag body
the tag handler, the tld, and the jsp
the taglib is just a name, not a location
the container builds a map
four places the container looks for tlds
when a jsp uses more than one tag library
coffee cram: mock exam chapter 9
coffee cram: chapter 9 answers
chapter 10 custom tag development: when even jstl is not enough...
includes and imports can be messy
tag files: like include, only better
but how do you send it parameters?
to a tag file, you don’t send request parameters, you send tag attributes!
aren’t tag attributes declared in the tld?
tag files use the attribute directive
when an attribute value is really big
declaring body-content for a tag file
where the container looks for tag files
when you need more than tag files... sometimes you need java
making a simple tag handler
a simple tag with a body
the simple tag api
the life of a simple tag handler
what if the tag body uses an expression?
a tag with dynamic row data: iterating the body
a simple tag with an attribute
what exactly is a jspfragment?
skippageexception: stops processing the page...
skippageexception shows everything up to the point of the exception
but what happens when the tag is invoked from an included page?
skippageexception stops only the page that directly invoked the tag
you still have to know about classic tag handlers
tag handler api
a very small classic tag handler
a classic tag handler with two methods
when a tag has a body: comparing simple vs. classic
classic tags have a different lifecycle
the classic lifecycle depends on return values
iterationtag lets you repeat the body
default return values from tagsupport
ok, let’s get real...
our dynamic
