Cookie mycook = new Cookie("name","value");

response.addCookie(mycook);

Cookie killmycook = new Cookie("mycook","value");

killmycook.setMaxAge(0);

killmycook.setPath("/");

killmycook.addCookie(killmycook);

Interface. And sends data into Streams in Compressed Format. It has

two methods, writeExternal(ObjectOuput out) and

readExternal(ObjectInput in).

Question What modifiers are allowed for methods in an Interface?

Answer Only public and abstract modifiers are allowed for

Question How many types of JDBC Drivers are present and what

are they? (JDBC)

Answer There are 4 types of JDBC Drivers

Answer Using <%jsp:param> tag.

 

tomcat6配置双向认证

1、生成服务器端证书

keytool -genkey -keyalg RSA -dname "cn=localhost,ou=sango,o=none,l=china,st=beijing,c=cn" -alias server -keypass password -keystore server.jks -storepass password -validity 3650

2、生成客户端证书

keytool -genkey -keyalg RSA -dname "cn=sango,ou=sango,o=none,l=china,st=beijing,c=cn" -alias custom -storetype PKCS12 -keypass password -keystore custom.p12 -storepass password -validity 3650

客户端的CN可以是任意值。
3、由于是双向SSL认证，服务器必须要信任客户端证书，因此，必须把客户端证书添加为服务器的信任认证。由于不能直接将PKCS12格式的证书库导入，我们必须先把客户端证书导出为一个单独的CER文件，使用如下命令，先把客户端证书导出为一个单独的cer文件：

keytool -export -alias custom -file custom.cer -keystore custom.p12 -storepass password -storetype PKCS12 -rfc

然后，添加客户端证书到服务器中（将已签名数字证书导入密钥库）

keytool -import -v -alias custom -file custom.cer -keystore server.jks -storepass password

4、查看证书内容

keytool -list -v -keystore server.jks -storepass password

5、配置tomcat service.xml文件

<Connector port="8443" protocol="HTTP/1.1" SSLEnabled="true"

    maxThreads="150" scheme="https" secure="true"

    clientAuth="true" sslProtocol="TLS"

    keystoreFile="D:/server.jks" keystorePass="password"

    truststoreFile="D:/server.jks" truststorePass="password"

/>

clientAuth="true"表示双向认证
6、导入客户端证书到浏览器
双向认证需要强制验证客户端证书。双击“custom.p12”即可将证书导入至IE

tomcat6配置单向认证

1、生成服务器端证书

keytool -genkey -keyalg RSA -dname "cn=localhost,ou=sango,o=none,l=china,st=beijing,c=cn" -alias server -keypass password -keystore server.jks -storepass password -validity 3650

2、由于是单向认证，没有必要生成客户端的证书，直接进入配置tomcat service.xml文件

<Connector port="8443" protocol="HTTP/1.1" SSLEnabled="true"

    maxThreads="150" scheme="https" secure="true"

    clientAuth="false" sslProtocol="TLS"

    keystoreFile="D:/server.jks" keystorePass="password"    

/>

clientAuth="false"表示单向认证，同时去掉truststoreFile="D:/server.jks" truststorePass="password"这2

---The key thing to know is that IDs identify a specific element and therefore must be unique on the page – you can only use a specific ID once per document. Many browsers do not enforce this rule but it is a basic rule of HTML/XHTML and should be observed. Classes mark elements as members of a group and can be used multiple times, so if you want to define a style which will be applied to multiple elements you should use a class instead.

 Notice that an ID's CSS is an HTML element, followed by a "#", and finally ID's name. The end result looks something like "element#idname". Also, be sure to absorb the fact that when an ID is used in HTML, we must use "id=name" instead of "class=name" to reference it!

       ID = A person's Identification (ID) is unique to one person.

       Class = There are many people in a class.

Standards specify that any given ID name can only be referenced once within a page or document. From our experience, IDs are most commonly used correctly in CSS layouts. This makes sense because there are usually only one menu per page, one banner, and usually only one content pane.

In Tizag.com CSS Layout Examples we have used IDs for the unique items mentioned above. View the CSS Code for our first layout example. Below are the unique IDs in our code.

       Menu - div#menuPane

       Content - div#content

Use IDs when there is only one occurence per page. Use classes when there are one or more occurences per page.

Architect (Java) Interview Questions

General and general terms questions

1. What distinguishes "good architecture" from "bad architecture"?
   This is an open-ended question. There are few aspects of "good" architecture:

   1. Shall address functional product requirements
   2. Shall address non-functional product requirements, such as performance, scalability, reliability, fault tolerance, availability, maintainability, extensibility
   3. Shall be simple and comprehendible (to support maintainability and extensibility)
   4. Shall be well structured (support multiple tiers, parallel development etc.)
   5. Shall be detailed enough to share with different levels of organizational structure (marketing, sales, development, management)

   "Bad" architecture is basically opposite to "good" architecture.
2. How much experience do you have with Enterprise applications? Another variant of this questions is: "Tell me about projects where you worked with J2EE?" Yet another version: "What, when and how made using EJB?"
   Interviewer is looking for your experience with designing J2EE applications and your experience with J2EE technologies and general terms. This is often start of the discussion and bridge to the technical section of the questions.
3. What is scalability?
4. What is high-availability? How is it different from scalability?
5. What is the fault tolerance?
6. What resources are used to keep up to date with J2EE technology?
   You may mention design pattern books, such as "Core EJB Patterns" and web sites, such as http://www.theserverside.com

Specific technical questions

1. What modeling tools you are familiar with? What version of TogetherJ (Rational Rose etc.) have you used?
2. If stateless session bean more scalable than stateful session beans?
   This is very popular questions that leads to some confusion. According to the second edition of "Core J2EE Patterns" and contrary to popular belief, stateful session beans are not less scalable than stateless session bean. The reason for that is life cycle of either type is controlled by Application Server and control of life cycle is what defines the scalability of the application
3. What's the difference between EJB 1.1 and EJB 2.0?
   There are many differences. Some key points you want to mention are:

   1. New CMP model
   2. EJB Query Language
   3. Local interfaces
   4. EJBHome methods
   5. Message Driven Beans (MDB) support
4. What transaction isolation levels do you know?
   none, repeatable read, read committed, read uncommitted, serializable
5. What transaction attributes do you know?
   requires new, required, supports, not supported, mandatory, never
6. What is the difference between optimistic lock and pessimistic lock?
   Optimistic lock is an implicit lock that tries to make best assumption about locking strategy and minimize time spent in lock of resource. Optimistic lock is usually implemented with some kind of timestamp strategy. Pessimistic lock is an explicit lock that set by client.
7. What are entity beans. Are there any issues with them?
   Typical reaction to this question is very expressive answer that entity beans should not be used. There are many performancy implications with entity beans if used incorrectly. One of the famous problems are "n+1 call problem" Inter-entity bean call is very expensive operation and should be avoided.
8. What core design patterns do you know?
   Architect must know at least some basic design patters used in J2EE development, e.g. Business Delegate, Session Facade, VO, List Handler, DTO, Composite Entity, etc.
9. Where business logic should reside?
   Typical answer is "in business tier" This usually opens series of questions like: What is business logic, how to determine business logic, how business logic is different from persistent logic etc.
10. What is JDO?
    JDO is Java Data Object - persistent framework that is alternative to idea of entity beans
11. What is the difference between JSP and servlet? When to use what?
    JSP is compiled into servlet. JSP are better suit to view of information, while servlets are better for controlling stuff.
12. Does the J2EE platform support nested transactions?
    No.
13. Can you use synchronization primitives in my enterprise beans?
    No.
14. Why all major application server vendors provide custom class loaders in addition to system jvm class loader?
    System one does not support hot deployment.

Performance questions

1. What are performance problems in J2EE and how to solve them?
2. What are Entity beans performance pitfalls?
3. What performance pattern do you know?

Design Pattern questions

1. Can you use singleton in EJB?
   Yes, but should not (explain why)
2. What is MVC pattern and why M, V and C need to be separated?
3. Describe Business Delegate pattern (or any other pattern)
4. How to prevent double submission of the form from JSP page? (or describe Synchronizer Token pattern)

Interview Questions on UML and Design Patterns

Why to use design patterns?
Give examples of design patterns?
What is UML?
What are advantages of using UML?
What is the need for modelling?
Is it requiste to use UML in software projects?
What are use cases? How did you capture use cases in your project?
Explain the different types of UML diagrams ? sequence diagram , colloboration diagram etc
What is the sequence of UML diagrams in project?
What tools did you use for UML in your project?
What is the difference between activity and sequence diagrams?
What are deployment diagrams?
What are the different object relationships ?
What is the difference between composition and aggregation?
Wheel acting as a part of car ? Is this composition or aggregation?

spring与自动调度任务(一)

面是自己自动调度的一些学习。
这里只采用jdk自带的timer进行的，准备在下篇文章中用Quartz调度器。
首先建立你自己要运行的类。

package com.duduli.li;

public class Display {

    public void disp(){
        System.out.println("自动控制测试");
    }
}

一个简单的java bean，其中在这里你可以替换自己的任务。
然后就是编写调度程序，这里要继承jdk中的TimerTask类，复写他的run方法。

package com.duduli.li;

import java.util.TimerTask;

public class AutoRan extends TimerTask {
    //set方法是spring的DI
    private Display display;
    
    public void setDisplay(Display display) {
        this.display = display;
    }
    @Override
    public void run() {
        display.disp();
    }
}

然后就是重要的一步，编写applicationsContext.xml了。

<?xml version="1.0" encoding="UTF-8"?>
<beans
    xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd">
    
    <bean id="display"
        class="com.duduli.li.Display">
    </bean>
    <bean id="atuoRun"
        class="com.duduli.li.AutoRan">
        <property name="display" ref="display"></property>
    </bean>
    
    <bean id="aR"
    class="org.springframework.scheduling.timer.ScheduledTimerTask">
        <property name="timerTask" ref="atuoRun"></property>
<!--
period多长时间运行一次，delay表示允许你当任务第一次运行前应该等待多久
-->
        <property name="period" value="5000"></property>
        <property name="delay" value="2000"></property>    
    </bean>
    
    <bean id="test"
    class="org.springframework.scheduling.timer.TimerFactoryBean">
        <property name="scheduledTimerTasks">
            <list>
<!--
这里使用list，可以调度多个bean，
-->
                <ref bean="aR"/>
            </list>
        </property>
    </bean>
</beans>

再来就是客户端调度了。

package com.duduli.li;

import org.springframework.beans.factory.BeanFactory;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Client {

    public static void main(String[] args) {
        BeanFactory factory = new ClassPathXmlApplicationContext("applicationContext.xml");
        factory.getBean("test");
    }
}

spring与自动调度任务(二)

使用quartz和spring自动调度。
具体实现bean：

package com.duduli.li.quartz;

import java.util.Date;

public class Display {

    @SuppressWarnings("deprecation")
    public void disp(){
        System.out.println(new Date().getSeconds());
        System.out.println("自动控制测试");
    }
}

继承quartzjobbean类：这个类和继承Timer类类似
。

package com.duduli.li.quartz;

import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
import org.springframework.scheduling.quartz.QuartzJobBean;

public class AutoRun extends QuartzJobBean{

    private Display  display;
    
    public void setDisplay(Display display) {
        this.display = display;
    }

    @Override
    protected void executeInternal(JobExecutionContext arg0)
            throws JobExecutionException {
        display.disp();
    }
}

spring配置文件：

                    <!-- quartz进行自动调度 -->
<!-- 具体实现类 -->
    <bean id="display2"    class="com.duduli.li.quartz.Display"></bean>
    
<!-- spring对quartz的支持，Auto类实现quartz的job接口的类，jobDataAsMap是将实现类注入其中 -->
    <bean id="quartz" class="org.springframework.scheduling.quartz.JobDetailBean">
        <property name="jobClass" value="com.duduli.li.quartz.AutoRun"/>
        <property name="jobDataAsMap">
            <map>
                <entry key="display" value-ref="display2"></entry>
            </map>
        </property>
    </bean>
    
<!-- spring对quartz的支持，对其值的设定 -->
    <bean id="simpleTask" class="org.springframework.scheduling.quartz.SimpleTriggerBean">
        <property name="jobDetail" ref="quartz"></property>
        <property name="startDelay" value="2000"></property>
        <property name="repeatInterval" value="2000"></property>
    </bean>
    
<!-- 启动自动调度 -->
    <bean id="quartzTest" class="org.springframework.scheduling.quartz.SchedulerFactoryBean">
        <property name="triggers">
            <list>
                <ref bean="simpleTask"/>
            </list>
        </property>
    </bean>

client调用：

package com.duduli.li.quartz;


import org.springframework.beans.factory.BeanFactory;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Client {

    public static void main(String[] args) {
            BeanFactory factory = new ClassPathXmlApplicationContext("applicationContext.xml");
            factory.getBean("quartzTest");
        }
}

Java implements a very efficient interprocess communication which reduces the CPU’s idle time to a very great extent. It is been implemented through wait ( ), notify ( ) and notifyAll ( ) methods. Since these methods are implemented as final methods they are present in all the classes.

The basic functionality of each one of them is as under:

■ wait( ) acts as a intimation to the calling thread to give up the monitor and go to sleep until some other thread enters the same monitor and calls notify( ).

■ notify( ) is used as intimator to wake up the first thread that called wait( ) on the same object.

■ notifyAll( ) as the term states wakes up all the threads that called wait( ) on the same object. The highest priority thread will run first.

public class WaitNotifyAllExample {
 
public static void main(String[] args) {
 
try {
Object o = new Object();
Thread thread1 = new Thread(new MyOwnRunnable("A", o));
Thread thread2 = new Thread(new MyOwnRunnable("B", o));
Thread thread3 = new Thread(new MyOwnRunnable("C", o));
 
// synchronized keyword acquires lock on the object.
synchronized (o) {
thread1.start();
// wait till the first thread completes execution.
// thread should acquire the lock on the object
// before calling wait method on it. Otherwise it will
// throw java.lang.IllegalMonitorStateException 
o.wait();
thread2.start();
// wait till the second thread completes execution
o.wait();
thread3.start();
}
 
}
catch (InterruptedException e) {
e.printStackTrace();
}
 
}
}
 
class MyOwnRunnable implements Runnable {
 
private String threadName;
 
private Object o;
 
public MyOwnRunnable(String name, Object o) {
threadName = name;
this.o = o;
}
 
public void run() {
 
 
synchronized (o) {
for (int i = 0; i < 1000; i++) {
System.out.println("Thread " + threadName + " Count : " + i);
}
// notify all threads waiting for the object o.
// thread should acquire the lock on the object
// before calling notify or notifyAll method on it. 
// Otherwise it will throw java.lang.IllegalMonitorStateException 
o.notifyAll();
}
}
}

 What are JavaScript types? - Number, String, Boolean, Function, Object, Null, Undefined.

1. How do you convert numbers between different bases in JavaScript? - Use the parseInt() function, that takes a string as the first parameter, and the base as a second parameter. So to convert hexadecimal 3F to decimal, use parseInt ("3F", 16);
2. What does isNaN function do? - Return true if the argument is not a number.
3. What is negative infinity? - It’s a number in JavaScript, derived by dividing negative number by zero.

4. What boolean operators does JavaScript support? - &&, || and !
5. What does "1"+2+4 evaluate to? - Since 1 is a string, everything is a string, so the result is 124.
6. How about 2+5+"8"? - Since 2 and 5 are integers, this is number arithmetic, since 8 is a string, it’s concatenation, so 78 is the result.
7. What looping structures are there in JavaScript? - for, while, do-while loops, but no foreach.
8. How do you create a new object in JavaScript? - var obj = new Object(); or var obj = {};
9. How do you assign object properties? - obj["age"] = 17 or obj.age = 17.
10. What’s a way to append a value to an array? - arr[arr.length] = value;
11. What is this keyword? - It refers to the current object.

 A SQL profile is sort of like gathering statistics on A QUERY - which involves many
tables, columns and the like....
In fact - it is just like gathering statistics for a query, it stores additional
information in the dictionary which the optimizer uses at optimization time to determine
the correct plan.  The SQL Profile is not "locking a plan in place", but rather giving
the optimizer yet more bits of information it can use to get the right plan.

My top javascripts

---. ExpandCollapse

 Used for expanding and collapsing block elements. I use this one for hiding divs or expanding the divs for forms. Very useful.

 function expandCollapse() {

for (var i=0; i<expandCollapse.arguments.length; i++) {

var element = document.getElementById(expandCollapse.arguments[i]);

element.style.display = (element.style.display == "none") ? "block" : "none";

 }

}

<p><em>Example:</em></p>

 <div id="on" style="border: 1px solid #90ee90;padding: 5px;">

   <a href="javascript: expandCollapse('expand', 'on');">Expand Layer</a>

 </div>

 <div id="expand" style="display: none;border: 1px solid #90ee90;padding: 5px;">

 <a href="javascript: expandCollapse('expand', 'on');">Collapse Layer</a>

 <p>Lorem ipsum dolor sit amet, consectetuer adipiscing elit. Quisque eu ligula.   Class aptent taciti sociosqu ad litora torquent per conubia nostra, per inceptos hymenaeos. Ut wisi. Curabitur odio. Sed ornare arcu id diam. Integer ultricies, mauris venenatis vulputate pulvinar</p>

</div>

--Timer Layer

Used for hiding an element after ‘x’ of seconds. Great for hiding status messages after a person has submitted a form.

var timerID;

function ShowLayer(id)

{

 document.getElementById().style.display = "block"; 

}

function HideTimedLayer(id)

{ 

    clearTimeout(timerID);

    document.getElementById(id). »

         style.display = "none";

}

function timedLayer(id)

{

 setTimeout("HideTimedLayer(""" + id + """)",»

  5000); //5000= 5 seconds

}

--Form Checker

Probably one of the most useful scripts and there are several out there about form validation. This figures out what fields are required from the value in in a hidden input tag. Than it highlights the error areas.

for (var j=0; j<myForm.elements.length; j++) {

var myElement = myForm.elements[j];

var isNull = false;

if (myElement.name == field && myElement.»

style.display != "none") {

if (myElement.type == "select-one" || »

myElement.type == "select-multiple") {

if ((myElement.options[myElement.selectedIndex].

»value == null || myElement.

»options[myElement.

»selectedIndex].value == '') 

»&& errorString.indexOf(title) == -1) {

isNull = true;

}

} else if ((myElement.value == null || 

»myElement.value.search(/"w/)»

 == -1) && errorString.indexOf(title) == -1) {

isNull = true;

}

if (isNull) {

errorString += title + ", ";

if (document.getElementById('label_'+myElement.name))»

 { document.getElementById('label_'+myElement.name)

 ».className="er"; }

myElement.className="erInput";

} else {

if (document.getElementById('label_'+myElement.name)) {

document.getElementById('label_'+myElement.name)

».className="s1";

}

myElement.className="s1";

}

}

}

}

if (errorString != '') {

errorString = errorString.slice(0,errorString.length-2);

window.alert("Please fill in the following 

»required fields before submitting this form:"n"n"+errorString)

return false;

}

else {

return true;

}

}

---今天练习了一下用javascript做文字自动匹配的功能，类似于Google Suggest，当然人家Google是连接后台数据库，在网上不方便做连接数据库，所有功能在前台实现。在javascript里定义了一个全局数组arrCities用来存储一些城市的名字。然后当我们在文本输入框里输入某个城市名字的时候，每输入完一个字，就会拿当前的文字到arrCities数组里去比对，看是否存在于arrCities的某个成员里。若存在，就把该成员添加到紧靠文本输入框下面的组合列表框里，供我们选择，这样我们就不用完全输入完整个城市的名字，只要
从下面选择一个就可以完成想要做的工作。看下面的例子：

<html>
<head>
<title>Autosuggest Example</title>
<script type="text/javascript">
var arrCities=["北京","上海"];
arrCities.sort();
//控制是否显示层div1,bFlag为true则表示显示div1,为false则把div1从页面流里移除
function showDiv1(bFlag){
var oDiv=document.getElementById("div1");
if(bFlag){
oDiv.style.display="block";
}
else{
oDiv.style.display="none";
}
};
//给sel1添加option
function addOption(oListbox,sText){
var oOption=document.createElement("option");
oOption.appendChild(document.createTextNode(sText));
oListbox.appendChild(oOption);
};
//移除一个option
function removeOption(oListbox,iIndex){
oListbox.remove(iIndex);
};
//移除所有的option
function clearOptions(oListbox){
for(var i=oListbox.options.length-1;i>=0;i--){
removeOption(oListbox,i);
}
};
//设置select里的第一个option被选中
function setFirstSelected(oListbox){
if(oListbox.options.length>0){
oListbox.options[0].selected=true;
}
}
//获取匹配的字段
function getAutosuggestMatches(sText,arrValues){
var arrResult=new Array;
if(sText!=""){
for(var i=0;i<arrValues.length;i++){
if(arrValues[i].indexOf(sText)==0){
arrResult.push(arrValues[i]);
}
}
}
else{
showDiv1(false);
}
return arrResult;
};
//把匹配的字段添加到sel1中
function addSuggestOptions(oTextbox,arrValues,sListboxId,oEvent){
var oListbox=document.getElementById(sListboxId);
clearOptions(oListbox);
var arrMatches=getAutosuggestMatches(oTextbox.value,arrValues);
if(arrMatches.length>0){
showDiv1(true);
for(var i=0;i<arrMatches.length;i++){
addOption(oListbox,arrMatches[i]);
}
setFirstSelected(oListbox);
if(oEvent.keyCode==8){
oTextbox.focus();
}
else{
oListbox.focus();
}
}
};
//获取select里的option到textbox
function getSuggestText(oListbox,sTextboxId){
var oTextbox=document.getElementById(sTextboxId);
if(oListbox.selectedIndex>-1){

oTextbox.value=oListbox.options[oListbox.selectedIndex].text;
}
oTextbox.focus();
showDiv1(false);
}
//通过Enter键确定选项
function getSuggestText2(oListbox,sTextboxId,oEvent){
if(oEvent.keyCode==13){
getSuggestText(oListbox,sTextboxId);
}
}
</script>
</head>
<body>
<p>请输入一个城市的名字：</p>
<p>
<input type="text" id="txt1" value="" size="27"
onkeyup="addSuggestOptions(this,arrCities,'sel1',event)" /><br />
<div id="div1" style="background-color:white;display:none;">
<select id="sel1" style="width:202px" size="6"
onclick="getSuggestText(this,'txt1')" onkeyup="getSuggestText2(this,'txt1',event)">
</select>
</div>
</p>
</body>
</html>

用到的东西都比较基础，当然有很多细节性的东西需要注意。比如说用户选择完一个选项，要注意把组合列表框隐藏。所以这里把组合列表框放在了一个层上，隐藏和显示控制起来就方便一点。

--js中innerHTML，innerText，outerHTML的用法和区别

用法：
<div id="test">
<span style="color:red">test1</span> test2
</div><div id="test">
<span style="color:red">test1</span> test2
</div>

在JS中可以使用：

test.innerHTML: 也就是从对象的起始位置到终止位置的全部内容,包括Html标签。
上例中的test.innerHTML的值也就是
<span style="color:red">test1</span> test2<span style="color:red">test1</span> test2

test.innerText: 从起始位置到终止位置的内容, 但它去除Html标签
上例中的text.innerTest的值也就是“test1 test2”, 其中span标签去除了。

test.outerHTML: 除了包含innerHTML的全部内容外, 还包含对象标签本身。
上例中的text.outerHTML的值也就是
<div id="test"><span style="color:red">test1</span> test2</div><div id="test"><span style="color:red">test1</span> test2</div>

完整示例：
<div id="test">
<span style="color:red">test1</span> test2
</div>

<a href="javascript：alert(test.innerHTML)">innerHTML内容</a>
<a href="javascript：alert(test.innerText)">inerHTML内容</a>
<a href="javascript：alert(test.outerHTML)">outerHTML内容</a><div id="test">
<span style="color:red">test1</span> test2
</div>

<a href="javascript：alert(test.innerHTML)">innerHTML内容</a>
<a href="javascript：alert(test.innerText)">inerHTML内容</a>
<a href="javascript：alert(test.outerHTML)">outerHTML内容</a>

特别说明：

--Javascript长文章分页

本例中实现用Javascript 长文章分页,Javascript 分页

<html>
<head>
<style type="text/css">
<!--
#jiax{
width:80%;/*调整显示区的宽*/
height:200px;/*调整显示区的高*/
font-size:14px;
line-height:180%;
border:1px solid #000000;
overflow-x:hidden;
overflow-y:hidden;
word-break:break-all;
}
a{
font-size:12px;
color:#000000;
text-decoration:underline;
}
a:hover{
font-size:12px;
color:#CC0000;
text-decoration:underline;
}
//-->
</style>
</head>
<body>
<div id="jiax">
本届都灵冬奥会，-------------------------------------------上届冬奥会，他们依然以13金傲视群雄。

</div>
<P>
<div id="pages" style="font-size:12px;"></div>
<script language="javascript">
<!--
var obj = document.getElementById("jiax");
var pages = document.getElementById("pages");
window.onload = function(){
var allpages = Math.ceil(parseInt(obj.scrollHeight)/parseInt(obj.offsetHeight));
pages.innerHTML = "<b>共"+allpages+"页</b>";
for (var i=1;i<=allpages;i++){
pages.innerHTML += "<a href=""javascript：showpart('"+i+"');"">第"+i+"页</a>&nbsp;";

}
}
function showpart(x){
obj.scrollTop=(x-1)*parseInt(obj.offsetHeight);
}
//-->
</script>
</body>
</html>

--用js实现select对div的隐藏与显示

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
"http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=gb2312">
<title>无标题文档</title>
</head>

<body>

<script type="text/javascript">
function change(a){
var xxx = document.getElementById("xxx");
var divArray = xxx.getElementsByTagName("div");
for (var i=0;i<divArray.length;i++) {
if (divArray[i].id == a) {
divArray[i].style.display='';
}else {
divArray[i].style.display='none';
}
}
}
</script>

<div id=xxx>

<div id=aaa>
<h1>aa</h1>
aaaa
</div>
<div id=bbb style="display:none ">
bbbb
</div>
<div id=ccc style="display:none ">
cccc
</div>

</div>

<select onChange="change(this.value)">
<option value="aaa">aaa</option>
<option value="bbb">bbb</option>
<option value="ccc">ccc</option>
</select>
</body>
</html>

---++日期减去天数等于第二个日期
<script language=Javascript>
function cc(dd,dadd)
{
//可以加上错误处理
var a = new Date(dd)
a = a.valueOf()
a = a - dadd * 24 * 60 * 60 * 1000
a = new Date(a)
alert(a.getFullYear() + "年" + (a.getMonth() + 1) + "月" + a.getDate() + "日")
}
cc("12/23/2002",2)
</script>

++++检查一段字符串是否全由数字组成
<script language="Javascript"><!--
function checkNum(str){return str.match(//D/)==null}
alert(checkNum("1232142141"))
alert(checkNum("123214214a1"))
// --></script>

+++++++++++++

--用js处理输出分页(完美版)

head>
<meta http-equiv="Content-Type" content="text/html; charset=gb2312" />
<title>无标题文档</title>
<style type="text/css">
<!--
div{font-size:14px;}
-->
</style>
</head>

<body>
<textarea name="" cols="" rows="" id="conpage" style="display:none;">
<!--pages-->
你好
<!--pages-->
我好
<!--pages-->
他也好
<!--pages-->
全都好
<!--pages-->
</textarea>
<script language="javascript">
var zhenze = /[^0-9]/;//创建正则,表明非数字字符串
var thispage = document.getElementById("conpage").value;//取得内容
var page_amount,x;
page_amount = thispage.split('<!--pages-->').length;
page_amount--;//内容里的pages个数
var asarray = new Array();//数组
var v=0;
for(var t=0;t<page_amount;t++){
asarray[t] = thispage.indexOf("<!--pages-->",v);//记录每个pages的位置
v=asarray[t];
v++;
};
page_amount--;
for(var s=0;s<page_amount;s++){
//以下是分段写出所有内容
document.write('<div id="pg'+(s+1)+'" style="block">');
document.write(thispage.substring(asarray[s],asarray[s+1]));
document.write('</div>');
alert(s+1);
};

var obj,objt;
var s_a_d = 1;//记录当前显示的页数id,默认为第1页显示，当设用showpage时，此变量用于记录上次所显示的页码，
function hidpage(hidt){//此函数用于隐藏页数
obj=eval("document.getElementById('pg"+hidt+"')");
obj.style.display = "none";
};

function showpage(sow){//此函数用于显示页数
obj = eval("document.getElementById('pg"+sow+"')");
objt = eval("document.getElementById('pg"+(s_a_d)+"')");//此句是取得上次显示的页码
objt.style.display = "none";//先隐藏上次显示的页码
obj.style.display = "block";//再显示当前用户需要显示的页码
s_a_d = sow;
document.getElementById("pageamo").value = sow;
alert("当前显示第"+s_a_d+"页");
};

var tts;
function goto(){ //页面转向函数,作用是用户在文本框里输入页码然后转向
tts = document.getElementById("inputpage").value;
if(!tts.match(zhenze)==""){
alert("错误，你输入了非数字类型字符");
return;
};
if(tts>page_amount || tts < 1){
alert("无此页");//非法输入全部检验完毕
}else{
showpage(tts);//合法的执行转向
};
};

document.write('<div>');
document.write('你现在在第<input type="button" id="pageamo" value="'+s_a_d+'" style="font-size:12px;height:18px;background-color:#FFFFFF; color:red;font-weight:bold;border:#FFFFFF 0px solid;">页 ');//标示当前页码
document.write('共有'+page_amount+'页');//总页数
for(var k=0;k<page_amount;k++){
document.write(' <a href="javascript：showpage('+(k+1)+')" style="text-decoration:none;">');
document.write(" ["+(k+1)+"] ");
document.write('</a> ');
hidpage(k+1);//隐藏所有页数
};//for写出页码 : 1 2 3 4 5 ....
showpage(1);//首先显示第一页内容
document.write(' 转到第 <input type="text" id="inputpage" style="width:20px;font-size:12px;height:18px;" value=""> 页');//转向表单
document.write('<input type="button" value=" Go " onclick="goto()" style="height:20px;">');
document.write('</div>');
</script>
</body>
</html>

This is a simple but powerful javascript to filter a standard html table. The user enters a term in a text field and just the table entries which contain it will be shown.

function filter (term, _id, cellNr){

               var suche = term.value.toLowerCase();

               var table = document.getElementById(_id);

               var ele;

               for (var r = 1; r < table.rows.length; r++){

                               ele = table.rows[r].cells[cellNr].innerHTML.replace(/<[^>]+>/g,"");

                               if (ele.toLowerCase().indexOf(suche)>=0 )

                                              table.rows[r].style.display = '';

                               else table.rows[r].style.display = 'none';

               }

}

This function searches in the table with the id defined by _id in every row in the cell defined by cellNr. The search is case insensitive.
The usage is straightforward:

<form>

               <input name="filter" onkeyup="filter(this, 'sf', 1)" type="text">

</form>

It should work with all modern browsers, e.g. IE5, Firefox 1.0, Opera 7 and Mozilla 1.0.

Since many people have asked for another version of the script which

• searches in every cell of a row
• searches for more than one keyword (using AND)

I have made another version of the script:

function filter2 (phrase, _id){

               var words = phrase.value.toLowerCase().split(" ");

               var table = document.getElementById(_id);

               var ele;

               for (var r = 1; r < table.rows.length; r++){

                               ele = table.rows[r].innerHTML.replace(/<[^>]+>/g,"");

                       var displayStyle = 'none';

                       for (var i = 0; i < words.length; i++) {

                                   if (ele.toLowerCase().indexOf(words[i])>=0)

                                              displayStyle = '';

                                  else {

                                              displayStyle = 'none';

                                              break;

                                   }

                       }

                               table.rows[r].style.display = displayStyle;

               }

}

Web designers must always keep usability in mind when designing web sites. A site must allow quick and easy access to information during the very short time that a site first holds a visitor's interest. Any confusion that ensues about where things are, and that person's business is gone. Providing a way to precisely search for what they need is an excellent way to provide that usability. What Chris Root explains in this article is a way for your visitors to find and select items contained in long lists. He will also suggest ways to expand this to searching within HTML or XML documents.

Auto-Complete

Many desktop applications have user interface controls that allow a user to find matches for things as they type. This feature can be very useful for long lists of items such as states, countries, streets or product categories. Many web browsers implement this sort of functionality in their address bars. As you type, web site address matches that are part of a list of recently visited sites appear in a menu below the address bar. This reduces the amount of time it takes to access information.

Another place this is implemented is in HTML select menus. Unfortunately this only works with the first letter typed, it is not implemented in all browsers on all platforms and it doesn't shorten the list of choices to only matches.

The script described in this article will allow a user to begin typing what they are looking for in a text box while a select menu updates itself with matches. In the example the list comes from the contents of the select menu but it can also come from other sources.

The HTML

The HTML for this project is pretty simple. You could however use this script several places in a large form with multiple lists of information with no trouble. This example uses a list of city streets.

<body onLoad="fillit(sel,entry)">
<div>Enter the first three letters of a street and select a match from the menu.</div>
<form><label>
Street
<input type="text" name="Street" id="entry" onKeyUp="findIt(sel,this)"><br>
  <select id="sel">
        <option value="s0001">Adams</option>
        <option value="s0002">Alder</option>
        <option value="s0003">Banner</option>
        <option value="s0004">Birchtree</option>
        <option value="s0005">Brook</option>
        <option value="s0007">Cooper</option>
<!--and so on and so forth-->
  </select></label>
</form>
</body>
</html>

When the text box registers a keyUp event, the find() function calls and passes two parameters, the id of the select menu and a reference to the text field.

For something like state information, allow the user the choice of using the auto-complete script or just selecting something from the menu, especially if they know the item they wish to select is at the top of the list. If someone lives in Alabama for instance, there is no need to have them enter the first three letters of their state when the item they want is at the top of the list of states. Fill the select menu (a list box can be used as well) with all the values and text labels that you want your user to choose from in the HTML code to start with.

Alternatively, depending on the information in the list, the choice may not be as obvious. In this case you could store it in an array only and the user would always need to select a match. If there was only one match, and that match was the correct one, they could leave the menu alone. Otherwise they would need to select from the available matches displayed in the menu.

The longer the list the more useful our script becomes. It has been tested with a list over 1000 city streets and had an acceptable performance, even on a not so modern machine. There is a minimum of two characters before a search will start. this helps reduce the number of matches shown after any given keystroke. This limit can be adjusted easily.

When the page loads, a function called fillit() is called.

//initialize some global variables
var list = null;;
function fillit(sel,fld)
{
        var field = document.getElementByid(fld);
        var selobj = document.getElementById(sel);
        if(!list)
        {
                ar len = selobj.options.length;
                field.value = "";
                list = new Array();
                for(var i = 0;i < len;i++)
                {
                        list[i] = new Object();
                        list[i]["text"] = selobj.options[i].text;
                        list[i]["value"] = selobj.options[i].value;
                }
        }
        else
        {
            var op = document.createElement("option");
            var tmp = null;
            for(var i = 0;i < list.length;i++)
           {
                tmp = op.cloneNode(true);
                tmp.appendChild(document.createTextNode(list[i]["text"]));
                tmp.setAttribute("value",list[i]["value"]);
                selobj.appendChild(tmp)/*;*/
           }
        }
}

A global variable is initialized to null. This will hold an array that in turn holds two custom objects to hold our data. We then get a reference to our select menu and text field objects. If our array does not exist yet (the page has just loaded so it’s still null), then we get the number of options in our select menu, set the contents of the text field to empty and begin looping through the menu contents.

As we run through each menu option, an object is created that will hold both what is in the value attribute and the text of the option tag.

If however our list array already exists, we are calling the function in order to refill the menu with all the original data. An option element is created and a temporary container is initialized.

In the loop the select menu is reconstructed using DOM methods.

Finding a Match

The findIt() function does the searching. It accepts two arguments. The first is the name of the select menu, the second is the name of the text field.

function findit(sel,field)
{
        var selobj = document.getElementById(sel);
        var d = document.getElementById("display");
        var len = list.length;
        if(field.value.length > 2)
        {
                if(!list)
                {
                        fillit(sel,field);
                }
                var op = document.createElement("option");
                selobj.options.length = 1
                var reg = new RegExp(field.value,"i");
                var tmp = null;
                var count = 0;
                var msg = "";
                for(var i = 0;i < len;i++)
                {
                        if(reg.test(list[i].text))
                        {
                                d.childNodes[0].nodeValue = msg;
                                tmp = op.cloneNode(true);
                                tmp.setAttribute("value",list[i].value);
                                tmp.appendChild(document.createTextNode(list[i].text));
                                selobj.appendChild(tmp);
                        }
                } 
        }
        else if(list && len > selobj.options.length)
        {
                selobj.selectedIndex = 0;
                fillit(sel,field);
        }
}

The first step is to get references to the select menu and the text field. We also need the length of the list array.

If the number of characters in the text field is greater than 2 and the list array exists. Then the menu is cleared of it's content to prepare it for display of any matches. The number of options is set to one rather than 0 to allow for an option that is always there such as a “Select a Street” option.

A regular expression object is then created that will be used to look for a match at the beginning of a given string. Using this object to create a regular expression allows the use of a string from whatever source we wish to be used along with any regular expression characters. The first parameter in the object constructor is the regular expression the second is any flags such as "i" for making the search case insensitive. If you were searching something other than one or two word street names, state names or country names you would want to match the beginning of word boundaries using ""b" instead of "^".

A few utility variables are initialized and we then loop through each of the list items contained in the arrays. If there is a match, the values are used to fill a new copy of the option element we created before the loop started. One thing to note about setting the properties of option elements is that the text label of an option is not an attribute. You must use the optionelement.text syntax rather than setAttribute to set the text label for each option.

If the length of the text in the field is less than 2 characters then we need to determine if the list needs to be refilled with all the values. By doing this, you allow the user to give up on their search before typing more than two characters and manually select something from the menu if they wish. If the user selects the text in the field and clears it to start a new search this will trigger that action. The fillit function is called and the select menu is refilled.

Possible Mods

To make this script and user interface more like the auto-complete widget in a browser address bar, you could use a DHTML menu and provide keyboard control for selecting a match and updating the content in the text box with the selected match.

This script would allow searching in any array of information and with a little modification any HTML collection. Searchable FAQ's, API documentation or help systems could be achieved by searching content contained in a hidden IFrame, the main HTML document itself or an XML document loaded in the background using the HTTPRequest object.

Conclusion

As you can see using auto-complete widgets on a web site can allow a visitor quick access to information. Always be on the lookout for ways to improve the user experience for your visitors and they will continue to come back for more.

1. How someone can define that a method should be execute inside read-only transaction semantics?

2.      What is the correct way to execute some code inside transaction using programmatic transaction management?

3. Select all statements that are correct.

4. Does this method guarantee that all of its invocations will process data with ISOLATION_SERIALIZABLE?
Assume txManager to be valid and only existing PlatformTransactionManager .
publicvoid query(){
       DefaultTransactionDefinition txDef =newDefaultTransactionDefinition();
       txDef.setIsolationLevel(TransactionDefinition.ISOLATION_SERIALIZABLE);
       txDef.setReadOnly(true);
       txDef.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRED);
       TransactionStatus txStat = txManager.getTransaction(txDef);
       // ...
       txManager.commit(txStat);
}

5. You would like to implement class with programmatic transaction management.
How can you get TransactionTemplate instance?

It's possible to inject either PlatformTransactionManager or TransactionTemplate in this class.
Option one is obviously wrong.

6. Check the correct default values for the @Transactional annotation.

7. To make a method transactional in a concrete class it's enough to use @Transactional annotation before the method name (in Java >=5.0).

correct answer

FALSE

explanation

No, @Transactional annotation only marks a method as transactional. To make it transactional it is necessary to include the <tx:annotation-driven/> element in XML configuration file.

Example Four :带自定义样式的数据(eg:Date)

群众：Date！么搞错，我昨天已经插入成功了~

小笔：是么？那我如果要你5/7/06 4：23这样输出你咋搞？

群众：无聊么？能写进去就行了！

小笔：一边凉快去~


                  HSSFWorkbook document = new HSSFWorkbook();

HSSFSheet sheet = document.createSheet("日期格式");

HSSFRow row = sheet.createRow(0);


HSSFCell secondCell = row.createCell((short) 0);

/**
 * 创建表格样式对象
 */
HSSFCellStyle style = document.createCellStyle();

/**
 * 定义数据显示格式
 */
style.setDataFormat(HSSFDataFormat.getBuiltinFormat("m/d/yy h:mm"));

/**
 * setter
 */
secondCell.setCellValue(new Date());

/**
 * 设置样式
 */
secondCell.setCellStyle(style);



File filePath = new File(baseDir+"excel/example/");

if(!filePath.exists())
filePath.mkdirs();

FileOutputStream fileSystem = new FileOutputStream(filePath.getAbsolutePath()+"/Four.xls");

document.write(fileSystem);

fileSystem.close();

Example Five:读取XLS文档


File filePath = new File(baseDir+"excel/example/");

if(!filePath.exists())
throw new Exception("没有该文件");
/**
 * 创建对XLS进行读取的流对象
 */
POIFSFileSystem reader = new POIFSFileSystem(new FileInputStream(filePath.getAbsolutePath()+"/Three.xls"));
/**
 * 从流对象中分离出文档对象
 */
HSSFWorkbook document = new HSSFWorkbook(reader);
/**
 * 通过文档对象获取Sheet
 */
HSSFSheet sheet = document.getSheetAt(0);
/**
 * 通过Sheet获取指定行对象
 */
HSSFRow row = sheet.getRow(0);
/**
 * 通过行、列定位Cell
 */
HSSFCell cell = row.getCell((short) 0);

/**
 * 输出表格数据
 */
log.info(cell.getStringCellValue());


至此，使用POI操作Excel的介绍告一段落，POI是一个仍然在不断改善的项目，有很多问题，比如说中文问题，大数据量内存溢出问题等等，但这个Pure Java的库的性能仍然是不容质疑的，是居家旅行必备良品。

而且开源软件有那么一大点好处是，可以根据自己的需要自己去定制。如果大家有中文、性能等问题没解决的，可以跟我索要我已经改好的库。当然，你要自己看原代码，我也不拦你。

Populating Value Objects from ActionForms

Problem

You don't want to have to write numerous getters and setters to pass data from your action forms to your business objects.

Solution

Use the introspection utilities provided by the Jakarta Commons BeanUtils package in your Action.execute( ) method:

import org.apache.commons.beanutils.*;
// other imports omitted
public ActionForward execute(ActionMapping mapping,
ActionForm form,
HttpServletRequest request,
HttpServletResponse response) throws Exception {
BusinessBean businessBean = new BusinessBean( );
BeanUtils.copyProperties(businessBean, form);
// ... rest of the Action

Discussion

A significant portion of the development effort for a web application is spent moving data to and from the different system tiers. Along the way, the data may be transformed in one way or another, yet many of these transformations are required because the tier to which the data is moving requires the information to be represented in a different way.

Data sent in the HTTP request is represented as simple text. For some data types, the value can be represented as a String object throughout the application. However, many data types should be represented in a different format in the business layer than on the view. Date fields provide the classic example. A date field is retrieved from a form's input field as a String. Then it must be converted to a java.util.Date in the model. Furthermore, when the value is persisted, it's usually transformed again, this time to a java.sql.Timestamp. Numeric fields require similar transformations.

The Jakarta Commons BeanUtils package supplied with the Struts distribution provides some great utilities automating the movement and conversion of data between objects. These utilities use JavaBean property names to match the source property to the destination property for data transfer. To leverage these utilities, ensure you give your properties consistent, meaningful names. For example, to represent an employee ID number, you may decide to use the property name employeeId. In all classes that contain an employee ID, you should use that name. Using empId in one class and employeeIdentifier in another will only lead to confusion among your developers and will render the BeanUtils facilities useless.

The entire conversion and copying of properties from ActionForm to business object can be performed with one static method call:

BeanUtils.copyProperties(
businessBean
, 
form
);

This copyProperties( ) method attempts to copy each JavaBean property in form to the property with the same name in businessBean. If a property in form doesn't have a matching property in businessBean, that property is silently ignored. If the data types of the matched properties are different, BeanUtils will attempt to convert the value to the type expected. BeanUtils provides converters from Strings to the following types:

• java.lang.BigDecimal

• java.lang.BigInteger

• boolean and java.lang.Boolean

• byte and java.lang.Byte

• char and java.lang.Character

• java.lang.Class

• double and java.lang.Double

• float and java.lang.Float

• int and java.lang.Integer

• long and java.lang.Long

• short and java.lang.Short

• java.lang.String

• java.sql.Date

• java.sql.Time

• java.sql.Timestamp

While the conversions to character-based and numeric types should cover most of your needs, date type fields (as shown in Recipe 3-13) can be problematic. A good solution suggested by Ted Husted is to implement transformation getter and setter methods in the business object that convert from the native type (e.g. java.util.Date) to a String and back again.

Because BeanUtils knows how to handle DynaBeans and the DynaActionForm implements DynaBean, the Solution will work unchanged for DynaActionForms and normal ActionForms.

As an example, suppose you want to collect information about an employee for a human resources application. Data to be gathered includes the employee ID, name, salary, marital status, and hire date. Example 5-9 shows the Employee business object. Most of the methods of this class are getters and setters; for the hireDate property, however, helper methods are provided that get and set the value from a String.

Example 5-9. Employee business object

package com.oreilly.strutsckbk.ch05;
import java.math.BigDecimal;
import java.text.DateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
public class Employee {
private String employeeId;
private String firstName;
private String lastName;
private Date hireDate;
private boolean married;
private BigDecimal salary;
public BigDecimal getSalary( ) {
return salary;
}
public void setSalary(BigDecimal salary) {
this.salary = salary;
}
public String getEmployeeId( ) {
return employeeId;
}
public void setEmployeeId(String employeeId) {
this.employeeId = employeeId;
}
public String getFirstName( ) {
return firstName;
}
public void setFirstName(String firstName) {
this.firstName = firstName;
}
public String getLastName( ) {
return lastName;
}
public void setLastName(String lastName) {
this.lastName = lastName;
}
public boolean isMarried( ) {
return married;
}
public void setMarried(boolean married) {
this.married = married;
}
public Date getHireDate( ) {
return hireDate;
}
public void setHireDate(Date HireDate) {
this.hireDate = HireDate;
}
public String getHireDateDisplay( ) {
if (hireDate == null)
return "";
else
return dateFormatter.format(hireDate);
}
public void setHireDateDisplay(String hireDateDisplay) {
if (hireDateDisplay == null)
hireDate = null;
else {
try {
hireDate = dateFormatter.parse(hireDateDisplay);
} catch (ParseException e) {
e.printStackTrace( );
}
}
}
private DateFormat dateFormatter = new SimpleDateFormat("mm/DD/yy");
}

Example 5-10 shows the corresponding ActionForm that will retrieve the data from the HTML form. The hire date is represented in the ActionForm as a String property, hireDateDisplay. The salary property is a java.lang.String, not a java.math.BigDecimal, as in the Employee object of Example 5-9.

Example 5-10. Employee ActionForm

package com.oreilly.strutsckbk.ch05;
import java.math.BigDecimal;
import org.apache.struts.action.ActionForm;
public class EmployeeForm extends ActionForm {
private String firstName;
private String lastName;
private String hireDateDisplay;
private String salary;
private boolean married;
public String getEmployeeId( ) {
return employeeId;
}
public void setEmployeeId(String employeeId) {
this.employeeId = employeeId;
}
public String getFirstName( ) {
return firstName;
}
public void setFirstName(String firstName) {
this.firstName = firstName;
}
public String getLastName( ) {
return lastName;
}
public void setLastName(String lastName) {
this.lastName = lastName;
}
public boolean isMarried( ) {
return married;
}
public void setMarried(boolean married) {
this.married = married;
}
public String getHireDateDisplay( ) {
return hireDateDisplay;
}
public void setHireDateDisplay(String hireDate) {
this.hireDateDisplay = hireDate;
}
public String getSalary( ) {
return salary;
}
public void setSalary(String salary) {
this.salary = salary;
}
}

If you wanted to use a DynaActionForm, you would configure it identically as the EmployeeForm class. The form-bean declarations from the struts-config.xml file show the declarations for the EmployeeForm and a functionally identical DynaActionForm:

<form-bean name="EmployeeForm"
type="com.oreilly.strutsckbk.ch05.EmployeeForm"/>
<form-bean name="EmployeeDynaForm"
type="org.apache.struts.action.DynaActionForm">
<form-property name="employeeId" type="java.lang.String"/>
<form-property name="firstName" type="java.lang.String"/>
<form-property name="lastName" type="java.lang.String"/>
<form-property name="salary" type="java.lang.String"/>
<form-property name="married" type="java.lang.Boolean"/>
<form-property name="hireDateDisplay" type="java.lang.String"/>
</form-bean>

The following is the action mapping that processes the form. In this case, the name attribute refers to the handcoded EmployeeForm. You could, however, change this to use the EmployeeDynaForm without requiring any modifications to the SaveEmployeeAction or the view_emp.jsp JSP page:

<action    path="/SaveEmployee"
name="EmployeeForm"
scope="request"
type="com.oreilly.strutsckbk.ch05.SaveEmployeeAction">
<forward name="success" path="/view_emp.jsp"/>
</action>

The data is converted and copied from the form to the business object in the SaveEmployeeAction shown in Example 5-11.

Example 5-11. Action to save employee data

package com.oreilly.strutsckbk.ch05;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.apache.commons.beanutils.BeanUtils;
import org.apache.struts.action.Action;
import org.apache.struts.action.ActionForm;
import org.apache.struts.action.ActionForward;
import org.apache.struts.action.ActionMapping;
public class SaveEmployeeAction extends Action {
public ActionForward execute(ActionMapping mapping,
ActionForm form,
HttpServletRequest request,
HttpServletResponse response)
throws Exception {
Employee emp = new Employee( );
// Copy to business object from ActionForm
BeanUtils.copyProperties( emp, form );
request.setAttribute("employee", emp);
return mapping.findForward("success");
}
}

Finally, two JSP pages complete the example. The JSP of Example 5-12 (edit_emp.jsp) renders the HTML form to retrieve the data.

Example 5-12. Form for editing employee data

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<%@ taglib uri="http://jakarta.apache.org/struts/tags-bean" prefix=
"bean" %>
<%@ taglib uri="http://jakarta.apache.org/struts/tags-html" prefix=
"html" %>
<%@ taglib uri="http://java.sun.com/jstl/core" prefix="c" %>
<html>
<head>
<title>Struts Cookbook - Chapter 5 : Add Employee</title>
</head>
<body>
<h2>Edit Employee</h2>
<html:form action="/SaveEmployee">
Employee ID: <html:text property="employeeId"/><br />
First Name: <html:text property="firstName"/><br />
Last Name: <html:text property="lastName"/><br />
Married? <html:checkbox property="married"/><br />
Hired on Date: <html:text property="hireDateDisplay"/><br />
Salary: <html:text property="salary"/><br />
<html:submit/>
</html:form>
</body>
</html>

The JSP in Example 5-13 (view_emp.jsp) displays the results. This page is rendering data from the business object, and not an ActionForm. This is acceptable since the data on this page is for display purposes only. This approach allows for the formatting of data, (salary and hireDate) to be different than the format in which the values were entered.

Example 5-13. View of submitted employee data

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<%@ taglib uri="http://jakarta.apache.org/struts/tags-bean" prefix=
"bean" %>
<%@ taglib uri="http://java.sun.com/jstl/core" prefix="c" %>
<html>
<head>
<title>Struts Cookbook - Chapter 5 : View Employee</title>
</head>
<body>
<h2>View Employee</h2>
Employee ID: <bean:write name="employee" property="employeeId"/><br />
First Name: <bean:write name="employee" property="firstName"/><br />
Last Name: <bean:write name="employee" property="lastName"/><br />
Married? <bean:write name="employee" property="married"/><br />
Hired on Date: <bean:write name="employee" property="hireDate"
format="MMMMM dd, yyyy"/><br />
Salary: <bean:write name="employee" property="salary" format="$##0.00"/
><br />
</body>
</html>

When you work with this example, swap out the handcoded form for the DyanActionForm to see how cleanly BeanUtils works. When you consider how many files need to be changed for one additional form input, the use of BeanUtils in conjunction with DynaActionForms becomes obvious.

2NF and 3NF

The 2NF and 3NF are very similar--the 2NF deals with composite primary keys and the 3NF deals with single primary keys. In general, if you do an ER diagram, convert many-to-many relationships to entities, and then convert all entities to tables, then your tables will already be in 3NF form.

Second normal form is violated when a non-key field is a fact about a subset of a key. It is only relevant when the key is composite, i.e., consists of several fields. Consider the following inventory record:

---------------------------------------------------

| PART | WAREHOUSE | QUANTITY | WAREHOUSE-ADDRESS |

====================-------------------------------

The key here consists of the PART and WAREHOUSE fields together, but WAREHOUSE-ADDRESS is a fact about the WAREHOUSE alone. The basic problems with this design are:

• The warehouse address is repeated in every record that refers to a part stored in that warehouse.
• If the address of the warehouse changes, every record referring to a part stored in that warehouse must be updated. Because of the redundancy, the data might become inconsistent, with different records showing different addresses for the same warehouse.
• If at some point in time there are no parts stored in the warehouse, there may be no record in which to keep the warehouse's address.

To satisfy second normal form, the record shown above should be decomposed into (replaced by) the two records:

------------------------------- --------------------------------- 

| PART | WAREHOUSE | QUANTITY | | WAREHOUSE | WAREHOUSE-ADDRESS |

====================----------- =============--------------------

The 3NF differs from the 2NF in that all non-key attributes in 3NF are required to be directly dependent on the primary key of the relation. The 3NF therefore insists that all facts in the relation are about the key (or the thing that the key identifies), the whole key and nothing but the key.

Third normal form is violated when a non-key field is a fact about another non-key field, as in

------------------------------------

| EMPLOYEE | DEPARTMENT | LOCATION |

============------------------------

The EMPLOYEE field is the key. If each department is located in one place, then the LOCATION field is a fact about the DEPARTMENT -- in addition to being a fact about the EMPLOYEE. The problems with this design are the same as those caused by violations of second normal form:

• The department's location is repeated in the record of every employee assigned to that department.
• If the location of the department changes, every such record must be updated.
• Because of the redundancy, the data might become inconsistent, with different records showing different locations for the same department.
• If a department has no employees, there may be no record in which to keep the department's location.

To satisfy third normal form, the record shown above should be decomposed into the two records:

------------------------- -------------------------

| EMPLOYEE | DEPARTMENT | | DEPARTMENT | LOCATION |

============-------------  ==============-----------

To summarize, a record is in second and third normal forms if every field is either part of the key or provides a (single-valued) fact about exactly the whole key and nothing else.

The Web Services Description Language (WSDL) currently represents the service description layer within the Web service protocol stack.
In a nutshell, WSDL is an XML grammar for specifying a public interface for a Web service. This public interface can include the following:
Information on all publicly available functions.
Data type information for all XML messages.
Binding information about the specific transport protocol to be used.
Address information for locating the specified service.
--

--Explain about stored procedures
--I/O Filter
--Two types of multi-tasking
--Explain lazy activation
--How can a dead thread be started
--What is meant by flickering
--How do you load an Image in a Servlet ?
--What is meant by class loader ? How many types are there? When will we use them ?
---Why there are some null interface in java ? What does it mean ? Give me some null interfaces in JAVA ?
--Write a program on RMI and JDBC using StoredProcedure ?
--Have you used threads in Servelet ?
--How do you invoke a Servelt?
--How will you pass parameters in RMI ?
--

--

--Question: What is similarities/difference between an Abstract class and Interface?
Answer:  Differences are as follows:

• Interfaces provide a form of multiple inheritance. A class can extend only one other class.
• Interfaces are limited to public methods and constants with no implementation. Abstract classes can have a partial implementation, protected parts, static methods, etc.
• A Class may implement several interfaces. But in case of abstract class, a class may extend only one abstract class.
• Interfaces are slow as it requires extra indirection to to find corresponding method in in the actual class. Abstract classes are fast. 

 --Question: What do you understand by Synchronization?
Answer: Synchronization is a process of controlling the access of shared resources by the multiple threads in such a manner that only one thread can access one resource at a time. In non synchronized multithreaded application, it is possible for one thread to modify a shared object while another thread is in the process of using or updating the object's value. Synchronization prevents such type of data corruption.
E.g. Synchronizing a function:
public synchronized void Method1 () {
     // Appropriate method-related code. 
}
E.g. Synchronizing a block of code inside a function:
public myFunction (){
    synchronized (this) { 
            // Synchronized code here.
         }
}
   --Question: What is Collection API?
Answer: The Collection API is a set of classes and interfaces that support operation on collections of objects. These classes and interfaces are more flexible, more powerful, and more regular than the vectors, arrays, and hashtables if effectively replaces. 
Example of classes: HashSet, HashMap, ArrayList, LinkedList, TreeSet and TreeMap.
Example of interfaces: Collection, Set, List and Map.
  --

  When a message arrives, the container calls the message-driven bean's onMessage method to process the message. The onMessage method normally casts the message to one of the five JMS message types and handles it in accordance with the application's business logic. The onMessage method may call helper methods, or it may invoke a session or entity bean to process the information in the message or to store it in a database.

  A message may be delivered to a message-driven bean within a transaction context, so that all operations within the onMessage method are part of a single transaction. If message processing is rolled back, the message will be redelivered.
  Session beans and entity beans allow you to send JMS messages and to receive them synchronously, but not asynchronously. To avoid tying up server resources, you may prefer not to use blocking synchronous receives in a server-side component. To receive messages asynchronously, use a message-driven bean.

Definition: An inner join is a join that selects only those records from both database tables that have matching values. Records with values in the joined field that do not appear in both of the database tables will be excluded from the query. One or more fields can serve as the join fields.
---Outer Join

Definition: An outer join selects all of the records from one database table and only those records in the second table that have matching values in the joined field. In a left outer join, the selected records will include all of the records in the first database table. In a right outer join, the selected records will include all records of the second database table. One or more fields can serve as the join fields.

       Service Buses: Connectors, Caching, Policies, Scripting, Messaging
       Infrastructure Components: SOAP bindings, XML parsers, Message service bindings, clustering, replication and high availability
--ESB:
   An enterprise service bus (ESB) is a pattern of middleware that unifies and connects services, applications and resources within a business. it's a new way of looking at how to integrate applications, coordinate resources and manipulate information,
the ESB pattern enables the connection of software running in parallel on different platforms, written in different programming languages and using different programming models.

		select emp from Employee emp
		select emp.id from Employee emp where exists ( from Education where name like 'Foo' and emp.id = employee.id )
		select emp.id from Employee emp where exists ( from Education edu where edu.name like 'Foo' and emp.id = employee.id )
		select * from Employee as emp where exists ( from Education as edu where edu.name like 'Foo' and emp.id = employee.id )
		from Employee as emp where exists ( from Education where name like 'Foo' and emp.id = employee.id )

<html>
<body>
<script>
var xmlstring = '<?xml version=\"1.0\"?>\
<shoppingcart date="14-10-2005" total="123.45">\
<item code="12345">\
<name>Widget</name>\
<quantity>1</quantity>\
</item>\
<item code="54321">\
<name>Another Widget</name>\
<quantity>2</quantity>\
</item>\
</shoppingcart>';
// convert the string to an XML object
var xmlobject = (new DOMParser()).parseFromString(xmlstring, "text/xml");
// get the XML root item
var root = xmlobject.getElementsByTagName('shoppingcart')[0];
var date = root.getAttribute("date");
alert("shoppingcart date=" + date);
var items = root.getElementsByTagName("item");
for (var i = 0 ; i < items.length ; i++) {
// get one item after another
var item = items[i];
// now we have the item object, time to get the contents
// get the name of the item
var name = item.getElementsByTagName("name")[0].firstChild.nodeValue;
// get the quantity
var quantity = item.getElementsByTagName("quantity")[0].firstChild.nodeValue;
alert("item #" + i + ": name=" + name + " quantity=" + quantity);
}
</script>
</body>
</html>

Example #2:
Here is a more universal example with the method "childNodes".
<html>
<body>
<script>
var xmlstring = '<?xml version="1.0"?>\
<root>\
<data>\
<row>\
<cell>Admiral</cell>\
<cell>Melon</cell>\
<cell>Carrot</cell>\
</row>\
<row>\
<cell>Captain</cell>\
<cell>Banana</cell>\
<cell>Zucchini</cell>\
</row>\
</data>\
<data>\
<row>\
<cell>Midshipman</cell>\
<cell>Orange</cell>\
<cell>Potatoe</cell>\
</row>\
</data>\
</root>';
// convert the string to an XML object
var xmlobject = (new DOMParser()).parseFromString(xmlstring, "text/xml");
// get the XML root item
var root = xmlobject.getElementsByTagName('root')[0];
for (var iNode = 0; iNode < root.childNodes.length; iNode++) {
var node = root.childNodes.item(iNode);
for (i = 0; i < node.childNodes.length; i++) {
var sibling = node.childNodes.item(i);
for (x = 0; x < sibling.childNodes.length; x++) {
var sibling2 = sibling.childNodes.item(x);
if (sibling2.childNodes.length > 0) {
var sibling3 = sibling2.childNodes.item(0);
alert(sibling3.data);
}
}
}
}
</script>
</body>
</html>

---Is there any way that an AJAX object can get back a record set?

You could build an XML document out of your recordset and send that back to the server, say you had a redord set for a "user" with the following details (name, surname, age, email), you could build an xml document like this:

Code:
<recordset>
     <user>
         <name>Byron</name>
         <surname>Tymvios</surname>
         <age>25</age>
         <email>email@address.com</email>
     </user>
     <user>
         <name>User</name>
         <surname>Someone</surname>
         <age>39</age>
         <email>myAddy@address.com</email>
     </user>
</recordset>

You can add as many records as you have in your recordset, then once the client has received it you can use javascript to iterate over the <user>'s in the xml.

var saveState = true;
if(saveState)
{
// This AJAX call will save the Navigator's state to session.
// We don't need a callback function because nothing happens
// once said state is saved.
var url = "AJAX_Servlet.aspx?function=saveNavigatorState&control=" + id + "&class=" + section.className + "";
req = new ActiveXObject("Microsoft.XMLHTTP");
req.open("POST", url, true);
req.send();
}

private void Page_Load(object sender, System.EventArgs e)
{
if(Request.QueryString["function"] != null)
{
if(Request.QueryString["function"] == "saveNavigatorState")
SaveNavigatorState();
}
}
private void SaveNavigatorState()
{
if(Request.QueryString["control"] != null && Request.QueryString["class"] != null)
{
string controlID = Request.QueryString["control"].ToString();
string className = Request.QueryString["class"].ToString();
Session[controlID] = className;
}
}

   Yet only a handful of those protocols are commonly used, chief amongst them is HTTP. HTTP is particularly attractive because it is accepted by corporate firewalls. Consequently, HTTP has outgrown its origins in Web browsing and has been adopted by many applications. For example, the latest XML protocols, such as SOAP, are also build on HTTP.

Java Support

Java supports HTTP through two APIs. The servlet API (and JSP) covers server-side programming while the java.net package offers client-side support through HttpURLConnection.

While I have had few problems with the servlet API, I have found that HttpURLConnection requires some work to interface with firewalls. All the services you need are available but the documentation is sketchy at best. Here are some of the problems I have encountered... and the solutions.

Typically, a client on a corporate network has no direct connection to the Internet. Access goes through proxy servers that monitor the traffic and enforce security rules.

The Basics

In the java.net API, proxies are supported through two system properties: http.proxyHost and http.proxyPort. They must be set to the proxy server and port respectively. The following code fragment illustrates it:

 String url = http://www.marchal.com/,

 proxy = "proxy.mydomain.com",

 port = "8080";

 URL server = new URL(url);

 Properties systemProperties = System.getProperties();

systemProperties.setProperty("http.proxyHost",proxy);

systemProperties.setProperty("http.proxyPort",port);

HttpURLConnection connection = (HttpURLConnection)server.openConnection();

connection.connect();

InputStream in = connection.getInputStream();

readResponse(in);          

Of course, you would need to use the proxy and port values suitable for your network. You can most likely find them in the configuration of your browser. If unsure, ask your system administrator.

Using Authentication

Increasingly, companies require employees to log in to the proxy before accessing the Internet. Login is used to better monitor Internet usage; for example, to monitor what sites are visited.

 HttpURLConnection supports proxy authentication through the Authenticator class. To enable authentication, your application subclasses Authenticator and defines the getPasswordAuthentication() method. A minimalist implementation is as follows:

 public class SimpleAuthenticator   extends Authenticator

         {

            private String username, password;

             public SimpleAuthenticator(String username,String password)

            {

               this.username = username;

               this.password = password;

                       }

            protected PasswordAuthentication getPasswordAuthentication()

                        {

               return new PasswordAuthentication(

                username,password.toCharArray();
                         }

              }

     Next, it must register the authenticator through Authenticator.setDefault(). If we adapt the previous code sample to use Authenticator, it looks like this:                        

         String url = "http://www.marchal.com/",

                                 proxy = "proxy.mydomain.com",

                                 port = "8080",     

                            username = "usr",

                            password = "pwd";             

         Authenticator.setDefault(new SimpleAuthenticator(username,password));     

         URL server = new URL(url);  

         Properties systemProperties = System.getProperties();    

       systemProperties.setProperty("http.proxyHost",proxy);            

         systemProperties.setProperty("http.proxyPort",port);               

         HttpURLConnection connection = ( HttpURLConnection)server.openConnection();

         connection.connect();

         InputStream in = connection.getInputStream();

         readResponse(in);                

A More Serious Issue

So far, I have covered the most common situations where HttpURLConnection works properly. However, I have encountered a few networks where HttpURLConnection is not usable.

 It appears that the problem is linked to a faulty configuration of the DNS server. For some reason, HttpURLConnection always attempts to resolve the host name against the DNS server. Normally, it fails gracefully and the connection goes is rerouted through the proxy server. A few DNS servers return an inappropriate answer that results in a UnknownHostException.

 There's an interesting theoretical debate as to whether the DNS server behaviour is acceptable. Although I am no expert on the topic, it would appear it is not. However, as a developer, you seldom have the option to reconfigure the DNS server, so you have to find a workaround.

 My solution is to roll out my own implementation of the HTTP protocol. In its simplest form, a GET request looks like the following listing:                                  

         String url = "http://www.marchal.com/",

         proxy = "proxy.mydomain.com",

         port = "8080",

         authentication = "usr:pwd";

         URL server = new URL(url);

         Socket socket = new Socket(proxy,port);

       Writer writer = new OutputStreamWriter(socket.getOutputStream(),   "US-ASCII");

         writer.write("GET " + server.toExternalForm() + " HTTP/1.0\r\n");

       writer.write("Host: " + server.getHost() + "\r\n");

         writer.write("Proxy-Authorization: Basic "

                      + new sun.misc.BASE64Encoder().encode(authentication.getBytes())+ "\r\n\r\n");

         writer.flush();

         BufferedReader reader = new BufferedReader(new InputStreamReader(         

                            socket.getInputStream(),"US-ASCII"));

         String line = reader.readLine();

         if(line != null && line.startsWith("HTTP/"))

         {

            int sp = line.indexOf(' ');

            String status = line.substring(sp + 1,sp + 4);

            if(status.equals("200"))

            {

               while(line.length() != 0)

                 line = reader.readLine();

               readResponse(reader);

            }

    else     throw new FileNotFoundException("Host reports error " +    status);

         }

 else

   throw new IOException("Bad protocol"); 

 reader.close();    

writer.close();

socket.close();            

Notice that the proxy username and password are given as username:password and are later encoded in base 64.

 Conclusion

HTTP is an interesting protocol because it is supported by all corporate firewalls. The Java developer needs to pay special attention to proxies and other authentication issues, though.

(3)假设在helloapp应用中有一个HelloServlet类，它在web.xml文件中的配置如下:
<servlet>
  <servlet-name> HelloServlet </servlet-name>
  <servlet-class>org.javathinker.HelloServlet</servlet-class>
</servlet>

<servlet-mapping>
  <servlet-name> HelloServlet </servlet-name>
  <url-pattern>/hello</url-pattern>
</servlet-mapping>
那么在浏览器端访问HelloServlet的URL是什么? （单选）
选项:
(A) http://localhost:8080/HelloServlet
(B) http://localhost:8080/helloapp/HelloServlet
(C) http://localhost:8080/helloapp/org/javathinker/hello
(D) http://localhost:8080/helloapp/hello


(4)客户请求访问HTML页面与访问Servlet有什么异同？（多选）
选项:
(A)相同：都使用HTTP协议
(B)区别：前者Web服务器直接返回HTML页面，后者Web服务器调用Servlet的方法，由Servlet动态生成HTML页面
(C)相同：前者Web服务器直接返回HTML页面,后者Web服务器直接返回Servlet的源代码。
(D)区别：后者需要在web.xml中配置URL路径。
(E)区别：前者使用HTTP协议，后者使用RMI协议。


(5)HttpServletRequest对象是由谁创建的?（单选）
选项:
(A)由Servlet容器负责创建，对于每个HTTP请求， Servlet容器都会创建一个HttpServletRequest对象
(B)由JavaWeb应用的Servlet或JSP组件负责创建，当Servlet或JSP组件响应HTTP请求时，先创建

HttpServletRequest对象


(6)从HTTP请求中，获得请求参数，应该调用哪个方法? （单选）
选项:
(A)调用HttpServletRequest对象的getAttribute()方法
(B)调用ServletContext对象的getAttribute()方法
(C)调用HttpServletRequest对象的getParameter()方法

(7)ServletContext对象是由谁创建的?（单选）
选项:
(A)由Servlet容器负责创建，对于每个HTTP请求， Servlet容器都会创建一个ServletContext对象
(B)由JavaWeb应用本身负责为自己创建一个ServletContext对象
(C)由Servlet容器负责创建，对于每个JavaWeb应用，在启动时，Servlet容器都会创建一个ServletContext对象


(8)jspForward1.jsp要把请求转发给jspForward2.jsp，应该在jspForward1.jsp中如何实现? （单选）
选项：
(A) <a href=“jspForward2.jsp”>jspForward2.jsp </a>
(B) <jsp:forward page=“jspForward2.jsp”>

(9)当浏览器第二次访问以下JSP网页时的输出结果是什么?（单选）

<!% int a=0;     %>
<%
     int b=0;
     a++;
     b++;
%>

a:<%= a %> <br>
b:<%= b %>
  
选项：
(A)  a=0  b=0
(B) a=1  b=1
(c) a=2  b=1

(10)下面哪个说法是正确的? （单选）
选项：
(A) 对于每个要求访问maillogin.jsp的HTTP请求，Servlet容器都会创建一个HttpSession对象
(B)每个HttpSession对象都有惟一的ID。
(C)JavaWeb应用程序必须负责为HttpSession分配惟一的ID

(11)如果不希望JSP网页支持Session，应该如何办? （单选）
选项：
(A) 调用HttpSession的invalidate()方法
(B) <%@ page session= “false\">


(12)在标签处理类中，如何访问session范围内的共享数据? （多选）
选项：
(A)在TagSupport类中定义了session成员变量，直接调用它的getAttribute()方法即可。
(B)在标签处理类TagSupport类中定义了pageContext成员变量，先通过它的getSession()方法获得当前的

HttpSession对象，再调用HttpSession对象的getAttribute()方法。
(C)pageContext.getAttribute(“attributename”,PageContext.SESSION_SCOPE)


(13)在下面的选项中，哪些是TagSupport类的doStartTag()方法的有效返回值? （多选）
选项：
(A) Tag.SKIP_BODY
(B) Tag.SKIY_PAGE
(C) Tag.EVAL_BODY_INCLUDE
(D) Tag.EVAL_PAGE


(14)以下代码能否编译通过，假如能编译通过，运行时得到什么打印结果？（单选）
request.setAttribute(\"count\",new Integer(0));
Integer count = request.getAttribute(\"count\");
选项：
A)不能编译通过  B)能编译通过，并正常运行  
C) 编译通过，但运行时抛出ClassCastException

》答案：
(1)C (2)D  (3)D  (4)A,B,D  (5)A  (6)C  (7)C  (8)B  (9)C   (10)B
(11)B  (12)B,C  (13)A,C  (14)A

判断题：（其它试题请下载）

1 ． Java 程序里 , 创建新的类对象用关键字 new ，回收无用的类对象使用关键字 free 。

2 ．对象可以赋值，只要使用赋值号（等号）即可，相当于生成了一个各属性与赋值对象相同的新对象。

3 ．有的类定义时可以不定义构造函数，所以构造函数不是必需的。

4 ．类及其属性、方法可以同时有一个以上的修饰符来修饰。

5 ． Java 的屏幕坐标是以像素为单位，容器的左下角被确定为坐标的起点

6 ．抽象方法必须在抽象类中，所以抽象类中的方法都必须是抽象方法。

7 ． Final 类中的属性和方法都必须被 final 修饰符修饰。

8 ．最终类不能派生子类，最终方法不能被覆盖。

9 ．子类要调用父类的方法，必须使用 super 关键字。

10 ．一个 Java 类可以有多个父类。

11 ．如果 p 是父类 Parent 的对象，而 c 是子类 Child 的对象，则语句 c = p 是正确的。

12 ．一个类如果实现了某个接口，那么它必须重载该接口中的所有方法。

13 ．当一个方法在运行过程中产生一个异常，则这个方法会终止，但是整个程序不一定终止运行。

14 ．接口是特殊的类，所以接口也可以继承，子接口将继承父接口的所有常量和抽象方法。

15 ．用“ + ”可以实现字符串的拼接，用 - 可以从一个字符串中去除一个字符子串。

16 ．使用方法 length( ) 可以获得字符串或数组的长度。

17 ．设 String 对象 s=”Hello ” ，运行语句 System.out.println(s.concat(“World!”)); 后 String 对象 s 的内容为 ”Hello world!” ，所以语句输出为

Hello world!

18 ．创建 Vector 对象时构造函数给定的是其中可以包容的元素个数，使用中应注意不能超越这个数值。

19 ．所有的鼠标事件都由 MouseListener 监听接口的监听者来处理。

20 ．一个容器中可以混合使用多种布局策略。

21 ． Java 中，并非每个事件类都只对应一个事件。

22 ．一个线程对象的具体操作是由 run() 方法的内容确定的，但是 Thread 类的 run() 方法是空的 , 其中没有内容 ; 所以用户程序要么派生一个 Thread 的子类并在子类里重新定义 run() 方法 , 要么使一个类实现 Runnable 接口并书写其中 run() 方法的方法体。

23 ． Java 的源代码中定义几个类，编译结果就生成几个以 .class 为后缀的字节码文件。

24 ． Java Applet 是由独立的解释器程序来运行的。

25 ． Java Applet 只能在图形界面下工作。

26 ． Java 的字符类型采用的是 ASCII 编码。

27 ． Java 的各种数据类型占用固定长度，与具体的软硬件平台环境无关

28 ． Applet 是一种特殊的 Panel ，它是 Java Applet 程序的最外层容器。

29 ．子类的域和方法的数目一定大于等于父类的域和方法的数目。

30 ． System 类不能实例化，即不能创建 System 类的对象。

31 ．用户自定义的图形界面元素也可以响应用户的动作，具有交互功能

32 ． Java 中数组的元素可以是简单数据类型的量，也可以是某一类的对象。

33 ． Vector 类中的对象不能是简单数据类型。

34 ． Java 中的 String 类的对象既可以是字符串常量，也可以是字符串变量。

35 ．容器是用来组织其他界面成分和元素的单元，它不能嵌套其他容器。

1. How EJB Invocation happens? - Retrieve Home Object reference from Naming Service via JNDI. Return Home Object reference to the client. Create me a new EJB Object through Home Object interface. Create EJB Object from the Ejb Object. Return EJB Object reference to the client. Invoke business method using EJB Object reference. Delegate request to Bean (Enterprise Bean).
2. Is it possible to share an HttpSession between a JSP and EJB? What happens when I change a value in the HttpSession from inside an EJB? - You can pass the HttpSession as parameter to an EJB method, only if all objects in session are serializable.This has to be consider as passed-by-value, that means that it’s read-only in the EJB. If anything is altered from inside the EJB, it won’t be reflected back to the HttpSession of the Servlet Container.The pass-by-reference can be used between EJBs Remote Interfaces, as they are remote references. While it is possible to pass an HttpSession as a parameter to an EJB object, it is considered to be bad practice in terms of object-oriented design. This is because you are creating an unnecessary coupling between back-end objects (EJBs) and front-end objects (HttpSession). Create a higher-level of abstraction for your EJBs API. Rather than passing the whole, fat, HttpSession (which carries with it a bunch of http semantics), create a class that acts as a value object (or structure) that holds all the data you need to pass back and forth between front-end/back-end. Consider the case where your EJB needs to support a non HTTP-based client. This higher level of abstraction will be flexible enough to support it.

3. The EJB container implements the EJBHome and EJBObject classes. For every request from a unique client, does the container create a separate instance of the generated EJBHome and EJBObject classes? - The EJB container maintains an instance pool. The container uses these instances for the EJB Home reference irrespective of the client request. while refering the EJB Object classes the container creates a separate instance for each client request. The instance pool maintenance is up to the implementation of the container. If the container provides one, it is available otherwise it is not mandatory for the provider to implement it. Having said that, yes most of the container providers implement the pooling functionality to increase the performance of the application server. The way it is implemented is, again, up to the implementer.
4. Can the primary key in the entity bean be a Java primitive type such as int? - The primary key can’t be a primitive type. Use the primitive wrapper classes, instead. For example, you can use java.lang.Integer as the primary key class, but not int (it has to be a class, not a primitive).
5. Can you control when passivation occurs? - The developer, according to the specification, cannot directly control when passivation occurs. Although for Stateful Session Beans, the container cannot passivate an instance that is inside a transaction. So using transactions can be a a strategy to control passivation. The ejbPassivate() method is called during passivation, so the developer has control over what to do during this exercise and can implement the require optimized logic. Some EJB containers, such as BEA WebLogic, provide the ability to tune the container to minimize passivation calls. Taken from the WebLogic 6.0 DTD -”The passivation-strategy can be either “default” or “transaction”. With the default setting the container will attempt to keep a working set of beans in the cache. With the “transaction” setting, the container will passivate the bean after every transaction (or method call for a non-transactional invocation).
6. What is the advantage of using Entity bean for database operations, over directly using JDBC API to do database operations? When would I use one over the other? - Entity Beans actually represents the data in a database. It is not that Entity Beans replaces JDBC API. There are two types of Entity Beans Container Managed and Bean Mananged. In Container Managed Entity Bean - Whenever the instance of the bean is created the container automatically retrieves the data from the DB/Persistance storage and assigns to the object variables in bean for user to manipulate or use them. For this the developer needs to map the fields in the database to the variables in deployment descriptor files (which varies for each vendor). In the Bean Managed Entity Bean - The developer has to specifically make connection, retrive values, assign them to the objects in the ejbLoad() which will be called by the container when it instatiates a bean object. Similarly in the ejbStore() the container saves the object values back the the persistance storage. ejbLoad and ejbStore are callback methods and can be only invoked by the container. Apart from this, when you use Entity beans you dont need to worry about database transaction handling, database connection pooling etc. which are taken care by the ejb container.
7. What is EJB QL? - EJB QL is a Query Language provided for navigation across a network of enterprise beans and dependent objects defined by means of container managed persistence. EJB QL is introduced in the EJB 2.0 specification. The EJB QL query language defines finder methods for entity beans with container managed persistenceand is portable across containers and persistence managers. EJB QL is used for queries of two types of finder methods: Finder methods that are defined in the home interface of an entity bean and which return entity objects. Select methods, which are not exposed to the client, but which are used by the Bean Provider to select persistent values that are maintained by the Persistence Manager or to select entity objects that are related to the entity bean on which the query is defined.
8. Brief description about local interfaces? - EEJB was originally designed around remote invocation using the Java Remote Method Invocation (RMI) mechanism, and later extended to support to standard CORBA transport for these calls using RMI/IIOP. This design allowed for maximum flexibility in developing applications without consideration for the deployment scenario, and was a strong feature in support of a goal of component reuse in J2EE. Many developers are using EJBs locally, that is, some or all of their EJB calls are between beans in a single container. With this feedback in mind, the EJB 2.0 expert group has created a local interface mechanism. The local interface may be defined for a bean during development, to allow streamlined calls to the bean if a caller is in the same container. This does not involve the overhead involved with RMI like marshalling etc. This facility will thus improve the performance of applications in which co-location is planned. Local interfaces also provide the foundation for container-managed relationships among entity beans with container-managed persistence.
9. What are the special design care that must be taken when you work with local interfaces? - It is important to understand that the calling semantics of local interfaces are different from those of remote interfaces. For example, remote interfaces pass parameters using call-by-value semantics, while local interfaces use call-by-reference. This means that in order to use local interfaces safely, application developers need to carefully consider potential deployment scenarios up front, then decide which interfaces can be local and which remote, and finally, develop the application code with these choices in mind. While EJB 2.0 local interfaces are extremely useful in some situations, the long-term costs of these choices, especially when changing requirements and component reuse are taken into account, need to be factored into the design decision.
10. What happens if remove( ) is never invoked on a session bean? - In case of a stateless session bean it may not matter if we call or not as in both cases nothing is done. The number of beans in cache is managed by the container. In case of stateful session bean, the bean may be kept in cache till either the session times out, in which case the bean is removed or when there is a requirement for memory in which case the data is cached and the bean is sent to free pool.
11. What is the difference between Message Driven Beans and Stateless Session beans? - In several ways, the dynamic creation and allocation of message-driven bean instances mimics the behavior of stateless session EJB instances, which exist only for the duration of a particular method call. However, message-driven beans are different from stateless session EJBs (and other types of EJBs) in several significant ways: Message-driven beans process multiple JMS messages asynchronously, rather than processing a serialized sequence of method calls. Message-driven beans have no home or remote interface, and therefore cannot be directly accessed by internal or external clients. Clients interact with message-driven beans only indirectly, by sending a message to a JMS Queue or Topic. Only the container directly interacts with a message-driven bean by creating bean instances and passing JMS messages to those instances as necessary. The Container maintains the entire lifecycle of a message-driven bean; instances cannot be created or removed as a result of client requests or other API calls.
12. How can I call one EJB from inside of another EJB? - EJBs can be clients of other EJBs. It just works. Use JNDI to locate the Home Interface of the other bean, then acquire an instance reference, and so forth.
13. What is an EJB Context? - EJBContext is an interface that is implemented by the container, and it is also a part of the bean-container contract. Entity beans use a subclass of EJBContext called EntityContext. Session beans use a subclass called SessionContext. These EJBContext objects provide the bean class with information about its container, the client using the bean and the bean itself. They also provide other functions. See the API docs and the spec for more details.

-- Facade: Provide a unified interface to a set of interfaces in a subsystem, it defines a higher-level interface that makes the subsystem easier to use.

Question: How you will handle exceptions in Struts?
Answer: In Struts you can handle the exceptions in two ways:
a) Declarative Exception Handling: You can either define global exception handling tags in your struts-config.xml or define the exception handling tags within <action>..</action> tag.
Example:
<exception 
      key="database.error.duplicate" 
      path="/UserExists.jsp" 
      type="mybank.account.DuplicateUserException"/>
b) Programmatic Exception Handling: Here you can use try{}catch{} block to handle the exception.
Question:Explain Struts navigation flow?
Struts Navigation flow.
1) A request is made from previously displayed view.
2) The request reaches the ActionServlet which acts as the controller .The ActionServlet Looksup the requested URI in an XML file (Struts-Config.xml) and determines the name of the Action class that has to perform the requested business logic.
3)The Action Class performs its logic on the Model Components associated with the Application.
4) Once The Action has been completed its processing it returns the control to the Action Servlet.As part of its return the Action Class provides a key to determine where the results should be forwarded for presentation.
5)The request is complete when the Action Servlet responds by forwarding the request to the view, and this view represents the result of the action.
Question: What is the purpose of tiles-def.xml file, resourcebundle.properties file, validation.xml file?
1. tiles-def.xml
  tiles-def.xml is used as a configuration file for an appliction during tiles development. You can define the layout / header / footer / body content for your View.
  Eg:
<tiles-definitions>
   <definition name="siteLayoutDef" path="/layout/thbiSiteLayout.jsp">
      <put name="title" value="Title of the page" />
      <put name="header" value="/include/thbiheader.jsp" />
      <put name="footer" value="/include/thbifooter.jsp" />
      <put name="content" type="string">
      Content goes here
   </put>
  </definition>
</tiles-definitions>

<tiles-definitions>
<definition name="userlogin" extends="siteLayoutDef">
<put name="content" value="/dir/login.jsp" />
</definition>
</tiles-definitions>

2. validation.xml
The validation.xml file is used to declare sets of validations that should be applied to Form Beans.
Each Form Bean you want to validate has its own definition in this file. Inside that definition, you specify the validations you want to apply to the Form Bean's fields. Eg:

<form-validation>
<formset>
<form name="logonForm">
<field property="username"
depends="required">
<arg0 key=" prompt.username"/>
</field>
<field property="password"
depends="required">
<arg0 key="prompt.password"/>
</field>
</form>
</formset>
</form-validation>

3. Resourcebundle.properties

Instead of having hard-coded error messages in the framework, Struts Validator allows you to specify a key to a message in the ApplicationResources.properties (or resourcebundle.properties) file that should be returned if a validation fails. Eg:

In ApplicationResources.properties
errors.registrationForm.name={0} Is an invalid name.
In the registrationForm.jsp
<html:messages id="messages" property="name">
<font color="red">
<bean:write name="messages" />
</html:messages>

Output(in red color) : abc Is an invalid name

=================

1. Purpose of tiles-def.xml file is used to in the design face of the webpage. For example in the webpage "top or bottom or left is
fixed" center might be dynamically chaged.
It is used for the easy design of the web sites. Reusability

2. resourcebundle.properties file is used for lot of purpose. One of its purpose is internationalization. We can make our page to view on any language. It is independent of it. Just based on the browser setting it selects the language and it displayed as you mentioned in the resourcebundle.properties file.

3. Validation rule.xml is used to put all the validation of the front-end in the validationrule.xml. So it verifies. If the same rule is applied in more than one page. No need to write the code once again in each page. Use validation to chek the errors in forms.

============================

tiles-def.xml - is required if your application incorporates the tiles framework in the "View" part of MVC. Generally we used to have a traditional JSP's (Which contgains HTML & java scriplets) are used in view. But Tiles is an advanced (mode or less ) implementation of frames used in HTML. We used to define the frames in HTML to seperate the header html, footer html, menu or left tree and body.html to reuse the contents. Hence in the same way, Tiles are defined to reuse the jsp's in struts like architectures, and we can define the jsp's which all are to be display at runtime, by providing the jsp names at runtime. To incorporate this we need tile-def.xml and the Class generally which extends RequestProcessor should extend TilesRequestProcessor.

resourcebundle.properties — It is to incorporate i18n (internationalization) in View part of MVC.

validation.xml - This file is responsible for business validations carried at server side before processing the request actually. It reduces the complexity in writing _JavaScript validations, and in this way, we can hide the validations from the user, in View of MVC.

Question: What we will define in Struts-config.xml file. And explain their purpose?
In struts-config.xml we define Date Sources / Form Beans / Global Exceptions / Global Forwards / Action Mappings / Message Resources / Plug-ins

Example :

<!– Date Sources –>
<data-sources>
<data-source autoCommit="false" description="First Database Config" driverClass=" org.gjt.mm.mysql.Driver" maxCount="4" minCount="2" password="admin" url="jdbc: mysql://localhost/ARTICLEDB" user="admin">
</<data-sources>
<!– Form Beans –>
<form-beans>
<form-bean name="registrationForm" type="com.aaa.merchant.wsp.ActionForms.RegistrationForm">
</form-bean>

<!– Global Exceptions –>
<global-exceptions>
<exception key="some.key" type="java.io.IOException" handler="com.yourcorp.ExceptionHandler"/>

</global-exceptions>

<!– A global-forward is retrieved by the ActionMapping findForward method. When the findForward method can't find a locally defined forward with the specified name, it searches the global-forwards available and return the one it finds.–>
<global-forwards>
<forward name="logoff" path="/logoff"/>
<forward name="logon" path="/logon.jsp"/>
</global-forwards>

<!– Actionn Mappings –>
<action-mappings>
<action path="/validateRegistration" type="com.dd.merchant.wsp.Actions.ValidateRegistration" validate="true" input="" name="registrationForm">
<forward name="success" path="/logon.jsp">
</forward>
</action>
</action-mappings>

<!– Message Resources –>
<message-resources parameter="wsppaymentsweb.resources.ApplicationResources"/>

<!– Plug-ins –>
<plug-in className="org.apache.struts.validator.ValidatorPlugIn">
<set-property property="pathnames" value="/WEB-INF/validator-rules.xml,/WEB-INF/validation.xml"/>
</plug-in>

===============================

Struts-Config.xml is one of the most important part of any web application based on Sturts. This file is responsible for instructing the Struts what forms are available, what actions are available, and also allows a number of plug-in models to be added to the base Struts package. It can contain Data Source Configuration,Form Bean Definitions, Global Forward Definitions,Action Mapping Definitions, Message Resources Definitions etc.

The most important are Form Bean Definitions, Global Forward Definitions,Action Mapping Definitions.

The <form-bean/> is configured using only two attributes, name and type and doesn't contain any body. The form-bean tag is used to describe an instance of a particular Form Bean that will be later bound to action.

The attribute name specifies the name of the form bean, which is a unique identifier to this form bean & the attribute type specifies the absolute path of the class file.

<global-forwards/>: It is also configured using only two attributes, name and path and there is also an optional attribute redirect. The <forward/> specifies the mapping of a logical name to a context-relative URI path. In the above sample xml file we can see, one of the <forward/> is specified with the name as failure and its corresponding path as index.jsp. That means whenever the logical name failure is encountered the action will be forwarded to the index.jsp page.

The optional attribute redirect is set to false by default. When it is set to true it causes the ActionServlet to use HttpSevletResponse.sendRedirect() method.

<action-mappings/>: The action mapping mainly defines the mapping between the logical Action name and the physical action class. Now lets have an understanding about its attributes.

· The attribute path must be compulsorily defined and it should start with a '/' character. It specifies the context relative path of the submitted request.

· The type attribute specifies the absolute path of the fully qualified class name of the Action class.

· The attribute name must be the same as that of the form bean name for which you want to associate the action.

· The attribute scope specifies the scope of the particular form bean which is an optional one and its default value is session.

· The next attribute validate is also an optional one which by default is set to true. When set to true, the validate() method in the form bean is called which gets associated with a particular Action.

· The next attribute, input is also optional. Whenever a validation error is encountered then the control returns to the path specified in the input attribute.

<controller/>: The <controller/> can be used to modify the default behaviour of the Struts Controller i.e, we can define a RequestProcessor.

===============================
In struts-config.xml, we define all the global-forwards, action mappings, view mappings, form-bean mappings, controller mapping and finally message-resources declaration if any.
Why we need to declare means, the Controller servelet defined in struts internally looks for this xml file for its proceddings. In real scenario, that the controller servlet inplemented internally is nothing but a slave to this struts-config.xml. The information provided in this file is nothing but like the intelligence to the controller servlet to say - what to do in which situation ?
So, Controller servlet, needs this file to proceede/ run the application.

What is DispatchAction?

DispatchAction is specialized child of Struts Action class. It combines or group the methods that can further access the bussiness logic at a single place. The method can be anyone from CRUD [Create,Retrieve,Update or Delete] or it can be security check one like autheniticate user etc.
This class apart from having thread-safe execute method also can have user-defined methods.
In struts-config.xml files following changes are required for Dispatch action to work:

<action-mappings>
<action path="/login"
type ="com…..LoginAction"
name ="loginForm"
parameter ="task"
scope = "request"
validate = "false"
input = "/index.jsp">
<forward name="success" path="/jsp/common/index.jsp"/>
<forward name="loginagain" path="/index.jsp"/>
</action>
</action-mappings>

If above is your struts-config.xml file structure and LoginAction extends DispatchAction instead of normal Action class. And assuming [keep assuming] your LoginAction class have method named authenticateUser, then in your login.jsp add any hidden parameter called task with value as your method name and on submit of that page following will be the url:

http://localhost:8080/yourproject/jsp/login.jsp?login.do&task=authenticateUser

Thus if we try to combine the last part of this puzzle we get the climax at struts-config.xml file's action-mapping tag described above. The parameter property of <action> tag have the task as it's value pointing to task variable in the request having it's value as authenticateUser hence the framework search in the LoginAction a method called authenticateUser through reflection and forwards the execution flow to it. This is all folks, the briallancy of Struts framework. Note DispatchAction class is included in 1.1 version.

How to call ejb from Struts?

We can call EJB from struts by using the service locator design patteren or by Using initial context with create home object and getting return remote referenc object.

What is the difference between ActionErrors and ActionMessages?

There is no differnece between these two classes.All the behavior of ActionErrors was copied into ActionMessages and vice versa. This was done in the attempt to clearly signal that these classes can be used to pass any kind of messages from the controller to the view — where as errors being only one kind of message.

The difference between saveErrors(…) and saveMessages(…) is simply the attribute name under which the ActionMessages object is stored, providing two convenient default locations for storing controller messages for use by the view. If you look more closely at the html:errors and html:messages tags, you can actually use them to get an ActionMessages object from any arbitrary attribute name in any scope.

What are the various Struts tag libraries?

The Struts distribution includes four tag libraries for the JSP framework (in struts-config.xml) :
* Bean tag library [ struts-bean.tld ] : Contains tags for accessing JavaBeans and their properties. Developers can also define new beans and set properties
* HTML tag library [ struts-html.tld ] : Contains tags to output standard HTML, including forms, textfields, checkboxes, radio buttons
* Logic tag library [ struts-logic.tld ] : Contains tags for generating conditional output, iteration capabilities and flow management
* Tiles or Template tag library [ struts-tiles.tld / struts-template.tld ] : For tiles implementation
* Nested tag library [ struts-nested.tld ] : allows the use of nested beans.

The libraries are designed to:

* Facilitate the separation of presentation and business logic.
* Dynamically generate Web pages.
* Implement the flow of control to and from the ActionServlet.

How you will handle errors and exceptions using Struts?

Struts exception handling can be done by two ways:
1. Declarative (using struts features via struts-config.xml)

<global-exceptions>
<exception
type="hansen.playground.MyException2"
key ="errors.exception2"
path="/error.jsp"/>
</global-exceptions>

This makes coding in the Action class very simple
Since the execute method declares throws Exception we don't need a try-catch block.
Struts saves the exception using one of its global constants. You may use the field G lobals.EXCEPTION_KEY to retrieve it from the request object.

2. Programmatic (using the usual try-catch exception handling in Action Class)

===============

We can Handle the errors by holding them into ActionError or ActionErrors classes defined by struts Framework. The other way around is by using the methods say saveErrors()….etc defined in Action class and can throw the error messages.

=================

Struts handles errors by providing the ActionErrors class which is
extended from org.apache.struts.action…
To install your customized exception handler, the first step is to
create a class that extends org.apache.struts.action.ExceptionHandler. There are
two methods that you can override, execute() and storeException().
For handling exceptions you have to mention in <global-exceptions> tag
of struts-config.xml which accepts attributes like exception type,key and
path.

How you will save the data across different pages for a particular client request using Struts?

One simple and general way is by using session Object.

In specific, we can pass this by using request Object as well.

======================================
Create an appropriate instance of ActionForm that is form bean and store that form bean in session scope. So that it is available to all the pages that for a part of the request.

request.getSession()
session.setAttribute()

What is Action Class? What are the methods in Action class?

An Action class is some thing like an adapter between the contents of an incoming HTTP request and the corresponding business logic that should be executed to process this request.
The controller (RequestProcessor) will select an appropriate Action for each request, create an instance (if necessary), and call the execute method. Struts Action class is a unit of logic. It is where a call to business function is made. In short the Action class acts like a bridge between client side(user action) and business operation(on server.
Some of the impotant methods of Action class are, execute()
generateToken() resetToken() getServlet()

Explain about token feature in Struts?

Use the Action Token methods to prevent duplicate submits:
There are methods built into the Struts action to generate one-use tokens. A token is placed in the session when a form is populated and also into the HTML form as a hidden property. When the form is returned, the token is validated. If validation fails, then the form has already been submitted, and the user can be apprised.
 saveToken(request)
on the return trip,
 isTokenValid(request)
resetToken(request)

What is the difference between ActionForm and DynaActionForm

# The DynaActionForm bloats up the Struts config file with the xml based definition. This gets annoying as the Struts Config file grow larger.

# The DynaActionForm is not strongly typed as the ActionForm. This means there is no compile time checking for the form fields. Detecting them at runtime is painful and makes you go through redeployment.

# ActionForm can be cleanly organized in packages as against the flat organization in the Struts Config file.

# ActionForm were designed to act as a Firewall between HTTP and the Action classes, i.e. isolate and encapsulate the HTTP request parameters from direct use in Actions. With DynaActionForm, the property access is no different than using request.getParameter( .. ).

# DynaActionForm construction at runtime requires a lot of Java Reflection (Introspection) machinery that can be avoided.

# Time savings from DynaActionForm is insignificant. It doesn t take long for today s IDEs to generate getters and setters for the ActionForm attributes. (Let us say that you made a silly typo in accessing the DynaActionForm properties in the Action instance. It takes less time to generate the getters and setters in the IDE than fixing your Action code and redeploying your web application)