Question
How do you delete a Cookie within a JSP? (JSP)Answer
Cookie mycook = new Cookie("name","value");
response.addCookie(mycook);
Cookie killmycook = new Cookie("mycook","value");
killmycook.setMaxAge(0);
killmycook.setPath("/");
killmycook.addCookie(killmycook);
Question
How many types of protocol implementations does RMI have? (RMI)Answer
RMI has at least three protocol implementations: JavaRemote Method Protocol(JRMP), Internet Inter ORB Protocol(IIOP),
and Jini Extensible Remote Invocation(JERI). These are alternatives,
not part of the same thing, All three are indeed layer 6 protocols for
those who are still speaking OSI reference model.
Question
What are the different identifier states of a Thread?(Core Java)
Answer
The different identifiers of a Thread are:R - Running or runnable thread
S - Suspended thread
CW - Thread waiting on a condition variable
MW - Thread waiting on a monitor lock
MS - Thread suspended waiting on a monitor lock
Question
What is the fastest type of JDBC driver? (JDBC)Answer
JDBC driver performance will depend on a number ofissues:
(a) the quality of the driver code,
(b) the size of the driver code,
(c) the database server and its load,
(d) network topology,
(e) the number of times your request is translated to a different API.
In general, all things being equal, you can assume that the more your
request and response change hands, the slower it will be. This
means that Type 1 and Type 3 drivers will be slower than Type 2
drivers (the database calls are make at least three translations versus
two), and Type 4 drivers are the fastest (only one translation).
Question
Request parameter How to find whether a parameterexists in the request object?
(Servlets)Answer
1.boolean hasFoo = !(request.getParameter("foo") ==null || request.getParameter("foo").equals(""));
2. boolean hasParameter =
request.getParameterMap().contains(theParameter);
(which works in Servlet 2.3+)
Question
How can I send user authentication information whilemakingURLConnection?
(Servlets)Answer
You’ll want to useHttpURLConnection.setRequestProperty and set all the appropriate
headers to HTTP authorization.
Question
How do I convert a numeric IP address like 192.18.97.39into a hostname like java.sun.com?
(Networking)Answer
Question
How many methods do u implement if implement theSerializable Interface?
(Core Java)Answer
The Serializable interface is just a "marker" interface,with no methods of its own to implement. Other ’marker’ interfaces
are
java.rmi.Remote
java.util.EventListener
String hostname =InetAddress.getByName("192.18.97.39").getHostName();]]>
Question
What is the query used to display all tables names inSQL Server (Query analyzer)?
(JDBC)Answer
select * from information_schema.tablesQuestion
What is Externalizable? (Core Java)Answer
Externalizable is an Interface that extends SerializableInterface. 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 formethods in interfaces.
Question
How many types of JDBC Drivers are present and whatare they?
(JDBC)Answer
There are 4 types of JDBC DriversType 1: JDBC-ODBC Bridge Driver
Type 2: Native API Partly Java Driver
Type 3: Network protocol Driver
Type 4: JDBC Net pure Java Driver
Question
What is the difference between ServletContext andPageContext?
(JSP) Answer ServletContext: Gives the information about the containerPageContext: Gives the information about the Request.
Question
How to pass information from JSP to included JSP? Answer Using <%jsp:param> tag.]]>
tomcat6閰嶇疆鍙屽悜璁よ瘉
1銆佺敓鎴愭湇鍔″櫒绔瘉涔?/span>
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鍙互鏄換鎰忓箋?/span>
3銆佺敱浜庢槸鍙屽悜SSL璁よ瘉錛屾湇鍔″櫒蹇呴』瑕佷俊浠誨鎴風璇佷功錛屽洜姝わ紝蹇呴』鎶婂鎴風璇佷功娣誨姞涓烘湇鍔″櫒鐨勪俊浠昏璇併傜敱浜庝笉鑳界洿鎺ュ皢PKCS12鏍煎紡鐨勮瘉涔﹀簱瀵煎叆錛屾垜浠繀欏誨厛鎶婂鎴風璇佷功瀵煎嚭涓轟竴涓崟鐙殑CER鏂囦歡錛屼嬌鐢ㄥ涓嬪懡浠わ紝鍏堟妸瀹㈡埛绔瘉涔﹀鍑轟負涓涓崟鐙殑cer鏂囦歡錛?/span>
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銆佹煡鐪嬭瘉涔﹀唴瀹?/span>
keytool -list -v -keystore server.jks -storepass password
5銆侀厤緗?/span>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銆佸鍏ュ鎴風璇佷功鍒版祻瑙堝櫒
鍙屽悜璁よ瘉闇瑕佸己鍒墮獙璇佸鎴風璇佷功銆傚弻鍑?/span>“custom.p12”鍗沖彲灝嗚瘉涔﹀鍏ヨ嚦IE
tomcat6閰嶇疆鍗曞悜璁よ瘉
1銆佺敓鎴愭湇鍔″櫒绔瘉涔?/span>
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"琛ㄧず鍗曞悜璁よ瘉錛屽悓鏃跺幓鎺?/span>truststoreFile="D:/server.jks" truststorePass="password"榪?/span>2
]]>
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!
Why Did They Choose Those Names??
ID = A person's Identification (ID) is unique to one person.
Class = There are many people in a class.
ID for Layout and Uniqueness
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
Answer: Classes vs IDs
Use IDs when there is only one occurence per page. Use classes when there are one or more occurences per page.
]]>
General and general terms questions
Architect interview is slightly different from all other interview types. Interviewer is looking for ability of the candidate to think independently on top of pure technical knowledge. Most of the questions are open-ended, prompting the interviewee to discussion about different aspects of Java development. Other side of the interview is general questions about position of the architect within the organization. Some questions do not have clear, direct or single answer and require discussion with the interviewer. On top of questions mentioned here you may be asked generic OO questions (what is class, what is polymorphism etc.)- What distinguishes "good architecture" from "bad architecture"?
This is an open-ended question. There are few aspects of "good" architecture:
- Shall address functional product requirements
- Shall address non-functional product requirements, such as performance, scalability, reliability, fault tolerance, availability, maintainability, extensibility
- Shall be simple and comprehendible (to support maintainability and extensibility)
- Shall be well structured (support multiple tiers, parallel development etc.)
- Shall be detailed enough to share with different levels of organizational structure (marketing, sales, development, management)
- 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.
- What is scalability?
- What is high-availability? How is it different from scalability?
- What is the fault tolerance?
- 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
- What modeling tools you are familiar with? What version of TogetherJ (Rational Rose etc.) have you used?
- 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
- What's the difference between EJB 1.1 and EJB 2.0?
There are many differences. Some key points you want to mention are:
- New CMP model
- EJB Query Language
- Local interfaces
- EJBHome methods
- Message Driven Beans (MDB) support
- What transaction isolation levels do you know?
none, repeatable read, read committed, read uncommitted, serializable
- What transaction attributes do you know?
requires new, required, supports, not supported, mandatory, never
- 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.
- 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.
- 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.
- 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.
- What is JDO?
JDO is Java Data Object - persistent framework that is alternative to idea of entity beans
- 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.
- Does the J2EE platform support nested transactions?
No.
- Can you use synchronization primitives in my enterprise beans?
No.
- 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
- What are performance problems in J2EE and how to solve them?
- What are Entity beans performance pitfalls?
- What performance pattern do you know?
Design Pattern questions
- Can you use singleton in EJB?
Yes, but should not (explain why)
- What is MVC pattern and why M, V and C need to be separated?
- Describe Business Delegate pattern (or any other pattern)
- How to prevent double submission of the form from JSP page? (or describe Synchronizer Token pattern)
]]>
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?
]]>
闈㈡槸鑷繁鑷姩璋冨害鐨勪竴浜涘涔犮?/span>
榪欓噷鍙噰鐢?/span>jdk鑷甫鐨?/span>timer榪涜鐨勶紝鍑嗗鍦ㄤ笅綃囨枃绔犱腑鐢?/span>Quartz璋冨害鍣ㄣ?/span>
棣栧厛寤虹珛浣犺嚜宸辮榪愯鐨勭被銆?/span>
package com.duduli.li;
public class Display {
public void disp(){
System.out.println("鑷姩鎺у埗嫻嬭瘯");
}
}
涓涓畝鍗曠殑java bean錛屽叾涓湪榪欓噷浣犲彲浠ユ浛鎹㈣嚜宸辯殑浠誨姟銆?/span>
鐒跺悗灝辨槸緙栧啓璋冨害紼嬪簭錛岃繖閲岃緇ф壙jdk涓殑TimerTask綾伙紝澶嶅啓浠栫殑run鏂規硶銆?/span>
package com.duduli.li;
import java.util.TimerTask;
public class AutoRan extends TimerTask {
//set鏂規硶鏄?/span>spring鐨?/span>DI
private Display display;
public void setDisplay(Display display) {
this.display = display;
}
@Override
public void run() {
display.disp();
}
}
鐒跺悗灝辨槸閲嶈鐨勪竴姝ワ紝緙栧啓applicationsContext.xml浜嗐?/span>
<?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錛屽彲浠ヨ皟搴﹀涓?/span>bean錛?/span>
-->
<ref bean="aR"/>
</list>
</property>
</bean>
</beans>
鍐嶆潵灝辨槸瀹㈡埛绔皟搴︿簡銆?/span>
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涓庤嚜鍔ㄨ皟搴︿換鍔?/span>(浜?/span>)
浣跨敤quartz鍜?/span>spring鑷姩璋冨害銆?/span>
鍏蜂綋瀹炵幇bean錛?/span>
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綾葷被浼?/span>
銆?/span>
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閰嶇疆鏂囦歡錛?/span>
<!-- quartz榪涜鑷姩璋冨害 -->
<!-- 鍏蜂綋瀹炵幇綾?/span> -->
<bean id="display2" class="com.duduli.li.quartz.Display"></bean>
<!-- spring瀵?/span>quartz鐨勬敮鎸侊紝Auto綾誨疄鐜?/span>quartz鐨?/span>job鎺ュ彛鐨勭被錛?/span>jobDataAsMap鏄皢瀹炵幇綾繪敞鍏ュ叾涓?/span> -->
<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瀵?/span>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璋冪敤錛?/span>
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");
}
}
]]>
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(); } } }
]]>
]]>