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.