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.