只有注冊用戶登錄后才能閱讀該文。閱讀全文

 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.

     摘要:   閱讀全文

(1)假設在helloapp應用中有一個hello.jsp，它的文件路徑如下: %CATALINA_HOME%/webapps/helloapp/hello/hello.jsp???? 那么在瀏覽器端訪問hello.jsp的URL是什么? （單選） 選項: (A) http://localhost:8080/hello.jsp (B) http://localhost:8080/helloapp/hello.jsp (C) http://localhost:8080/helloapp/hello/hello.jsp (2)假設在helloapp應用中有一個HelloServlet類，它位于org.javathinker包下，那么這個類的class文件應該放 在什么目錄下? （單選） 選項: (A) helloapp/HelloServlet.class (B) helloapp/WEB-INF/HelloServlet.class (C) helloapp/WEB-INF/classes/HelloServlet.class (D) helloapp/WEB-INF/classes/org/javathinker/HelloServlet.class

(3)假設在helloapp應用中有一個HelloServlet類，它在web.xml文件中的配置如下:
<servlet>
??<servlet-name> HelloServlet </servlet-name>
??<servlet-class>org.javathinker.HelloServlet</servlet-class>
</servlet>

<servlet-mapping>
??<servlet-name> HelloServlet </servlet-name>
??<url-pattern>/hello</url-pattern>
</servlet-mapping>
那么在瀏覽器端訪問HelloServlet的URL是什么? （單選）
選項:
(A) http://localhost:8080/HelloServlet
(B) http://localhost:8080/helloapp/HelloServlet
(C) http://localhost:8080/helloapp/org/javathinker/hello
(D) http://localhost:8080/helloapp/hello


(4)客戶請求訪問HTML頁面與訪問Servlet有什么異同？（多選）
選項:
(A)相同：都使用HTTP協議
(B)區別：前者Web服務器直接返回HTML頁面，后者Web服務器調用Servlet的方法，由Servlet動態生成HTML頁面
(C)相同：前者Web服務器直接返回HTML頁面,后者Web服務器直接返回Servlet的源代碼。
(D)區別：后者需要在web.xml中配置URL路徑。
(E)區別：前者使用HTTP協議，后者使用RMI協議。


(5)HttpServletRequest對象是由誰創建的?（單選）
選項:
(A)由Servlet容器負責創建，對于每個HTTP請求， Servlet容器都會創建一個HttpServletRequest對象
(B)由JavaWeb應用的Servlet或JSP組件負責創建，當Servlet或JSP組件響應HTTP請求時，先創建

HttpServletRequest對象


(6)從HTTP請求中，獲得請求參數，應該調用哪個方法? （單選）
選項:
(A)調用HttpServletRequest對象的getAttribute()方法
(B)調用ServletContext對象的getAttribute()方法
(C)調用HttpServletRequest對象的getParameter()方法

(7)ServletContext對象是由誰創建的?（單選）
選項:
(A)由Servlet容器負責創建，對于每個HTTP請求， Servlet容器都會創建一個ServletContext對象
(B)由JavaWeb應用本身負責為自己創建一個ServletContext對象
(C)由Servlet容器負責創建，對于每個JavaWeb應用，在啟動時，Servlet容器都會創建一個ServletContext對象


(8)jspForward1.jsp要把請求轉發給jspForward2.jsp，應該在jspForward1.jsp中如何實現? （單選）
選項：
(A) <a href=“jspForward2.jsp”>jspForward2.jsp </a>
(B) <jsp:forward page=“jspForward2.jsp”>

(9)當瀏覽器第二次訪問以下JSP網頁時的輸出結果是什么?（單選）

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

a:<%= a %> <br>
b:<%= b %>
??
選項：
(A)??a=0??b=0
(B) a=1??b=1
(c) a=2??b=1

(10)下面哪個說法是正確的? （單選）
選項：
(A) 對于每個要求訪問maillogin.jsp的HTTP請求，Servlet容器都會創建一個HttpSession對象
(B)每個HttpSession對象都有惟一的ID。
(C)JavaWeb應用程序必須負責為HttpSession分配惟一的ID

(11)如果不希望JSP網頁支持Session，應該如何辦? （單選）
選項：
(A) 調用HttpSession的invalidate()方法
(B) <%@ page session= “false\">


(12)在標簽處理類中，如何訪問session范圍內的共享數據? （多選）
選項：
(A)在TagSupport類中定義了session成員變量，直接調用它的getAttribute()方法即可。
(B)在標簽處理類TagSupport類中定義了pageContext成員變量，先通過它的getSession()方法獲得當前的

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


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


(14)以下代碼能否編譯通過，假如能編譯通過，運行時得到什么打印結果？（單選）
request.setAttribute(\"count\",new Integer(0));
Integer count = request.getAttribute(\"count\");
選項：
A)不能編譯通過??B)能編譯通過，并正常運行??
C) 編譯通過，但運行時拋出ClassCastException

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

判斷題：（其它試題請下載）

1 ． Java 程序里 , 創建新的類對象用關鍵字 new ，回收無用的類對象使用關鍵字 free 。

2 ．對象可以賦值，只要使用賦值號（等號）即可，相當于生成了一個各屬性與賦值對象相同的新對象。

3 ．有的類定義時可以不定義構造函數，所以構造函數不是必需的。

4 ．類及其屬性、方法可以同時有一個以上的修飾符來修飾。

5 ． Java 的屏幕坐標是以像素為單位，容器的左下角被確定為坐標的起點

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

7 ． Final 類中的屬性和方法都必須被 final 修飾符修飾。

8 ．最終類不能派生子類，最終方法不能被覆蓋。

9 ．子類要調用父類的方法，必須使用 super 關鍵字。

10 ．一個 Java 類可以有多個父類。

11 ．如果 p 是父類 Parent 的對象，而 c 是子類 Child 的對象，則語句 c = p 是正確的。

12 ．一個類如果實現了某個接口，那么它必須重載該接口中的所有方法。

13 ．當一個方法在運行過程中產生一個異常，則這個方法會終止，但是整個程序不一定終止運行。

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

15 ．用“ + ”可以實現字符串的拼接，用 - 可以從一個字符串中去除一個字符子串。

16 ．使用方法 length( ) 可以獲得字符串或數組的長度。

17 ．設 String 對象 s=”Hello ” ，運行語句 System.out.println(s.concat(“World!”)); 后 String 對象 s 的內容為 ”Hello world!” ，所以語句輸出為

Hello world!

18 ．創建 Vector 對象時構造函數給定的是其中可以包容的元素個數，使用中應注意不能超越這個數值。

19 ．所有的鼠標事件都由 MouseListener 監聽接口的監聽者來處理。

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

21 ． Java 中，并非每個事件類都只對應一個事件。

22 ．一個線程對象的具體操作是由 run() 方法的內容確定的，但是 Thread 類的 run() 方法是空的 , 其中沒有內容 ; 所以用戶程序要么派生一個 Thread 的子類并在子類里重新定義 run() 方法 , 要么使一個類實現 Runnable 接口并書寫其中 run() 方法的方法體。

23 ． Java 的源代碼中定義幾個類，編譯結果就生成幾個以 .class 為后綴的字節碼文件。

24 ． Java Applet 是由獨立的解釋器程序來運行的。

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

26 ． Java 的字符類型采用的是 ASCII 編碼。

27 ． Java 的各種數據類型占用固定長度，與具體的軟硬件平臺環境無關

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

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

30 ． System 類不能實例化，即不能創建 System 類的對象。

31 ．用戶自定義的圖形界面元素也可以響應用戶的動作，具有交互功能

32 ． Java 中數組的元素可以是簡單數據類型的量，也可以是某一類的對象。

33 ． Vector 類中的對象不能是簡單數據類型。

34 ． Java 中的 String 類的對象既可以是字符串常量，也可以是字符串變量。

35 ．容器是用來組織其他界面成分和元素的單元，它不能嵌套其他容器。

     摘要: Part I. XSLT Programming ? 1)?? What is the exac...  閱讀全文      摘要:   閱讀全文      摘要:   閱讀全文

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: Java

Remote 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 of

issues:

(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 parameter

exists 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 while

makingURLConnection? (Servlets)

Answer You’ll want to use

HttpURLConnection.setRequestProperty and set all the appropriate

headers to HTTP authorization.

Question How do I convert a numeric IP address like 192.18.97.39

into a hostname like java.sun.com? (Networking)

Answer

Question How many methods do u implement if implement the

Serializable 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();

1.

Question What is the query used to display all tables names in

SQL Server (Query analyzer)? (JDBC)

Answer select * from information_schema.tables

Question What is Externalizable? (Core Java)

Answer Externalizable is an Interface that extends Serializable

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

methods in interfaces.

Question How many types of JDBC Drivers are present and what

are they? (JDBC)

Answer There are 4 types of JDBC Drivers

Type 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 and

PageContext? (JSP)

Answer ServletContext: Gives the information about the container

PageContext: Gives the information about the Request.

Question How to pass information from JSP to included JSP?

Answer Using <%jsp:param> tag.

posted @ 2010-10-25 16:07 Sun River| 編輯 收藏

 

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.

--Spring的singleton是容器級的，我們一般說的singleton模式是JVM級的。所以singleton模式中，singleton的class在整個JVM中只有一個instance，Spring的Bean，你可以一個class配置多個Bean，這個class就有了多個instance。這個singleton是指在spring容器中，這個Bean是單實例的，是線程共享的。所以要求這些類都是線程安全的。也就是說，不能出現修改Bean屬性的方法，當然除了設值得那些setter。只要滿足線程安全，這些bean都可以用singleton。而且我們在絕大多數使用上，也是這樣用的，包括dao,service。
Beanfactory是Spring初始以靜態方式載入的,Spring的單例IOC是基于容器級的,所以這你都不用擔心與考慮.

--應用中對象有兩種，行為對象和數據對象，行為對象都要求是線程安全的！也就是允許單例的, 不管是dao 還是 service 對象，都是行為對象，行為對象不應該引用非線程安全的對象做成員量，同時在應用外部的資源（如文件，數據庫連接，session）時，要先保證對這些東西的訪問是做了并發控制的！
  對于spring來講，<bean scope="singleton"/>或<bean singleton="true"/>都是保證對同一sesionfactory bean是單例的，也就是所謂 sessionfactory 范圍的.

--這是一個真實的案例，我們在項目中使用Spring和ACEGI,我之所以選擇ACEGI，除了它對權限的良好控制外，
我還看好它的SecurityContextHolder，通過代碼
<script>render_code();</script>
我可以很容易在系統任意一層得到用戶的信息，而不用把用戶信息在參數里傳來傳去，(這也是struts的缺點之一)
但是我在每一次要得到用戶信息的時候都寫上面的一段代碼，未免有些麻煩，所以我在BaseService, BaseDao里都提供了如下方法：

Architect (Java) Interview Questions

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.)

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();
}
}
}

    只有注冊用戶登錄后才能閱讀該文。閱讀全文