2008年6月3日
#
1. Remote
Method Invocation (RMI)
2. Hessian
3. Burlap
4. HTTP invoker
5. EJB
6. JAX-RPC
7. JMX
zz from http://marakana.com/forums/tomcat/general/106.html
Valve and Filter:
"Valve" is Tomcat
specific notion, and they get applied at a higher level than anything in a specific webapp. Also, they work only in Tomcat.
"Filter" is a Servlet Specification notion and should work in any compliant servlet container. They get applied at a lower level than all of Tomcat's
Valves.
However, consider also the division between your application and the application
server. Think whether the feature you're planning is part of your application, or is it rather a generic feature of the application server, which could have uses in other applications as well. This would be the correct criteria to decide between Valve and Filter.
Order for filter: The order in which they are
defined matters. The container will execute the filters in the order
in which they are defined.
Use one single table "blank_fields" for both A and B. "blank_fields" has fields: 'ref_id', 'blank_field', 'type'. 'type' is used to identify which entity the record belongs to. Use 'type' + 'ref_id' to specify the collection of elements for one entity.
@Entity
@Table(name = "table_a")
public class A {
private Set<BlankField> blankFields = new HashSet<BlankField>();
@CollectionOfElements
@Fetch(FetchMode.SUBSELECT)
@Enumerated(EnumType.ORDINAL)
@JoinTable(name = "blank_fields", joinColumns = { @JoinColumn(name = "ref_id") })
@Cascade(value = org.hibernate.annotations.CascadeType.DELETE_ORPHAN)
@Column(name = "blank_field", nullable = false)
@SQLInsert(sql = "INSERT INTO blank_fields(ref_id, blank_field, type) VALUES(?,?,0)")
@Where(clause = "type=0")
public Set<BlankField> getBlankFields() { // BlankField is an enum
return blankFields;
}
@SuppressWarnings("unused")
private void setBlankFields(Set<BlankField> blankFields) {
this.blankFields = blankFields;
}
} // End B
@Entity
@Table(name = "table_b")
public class B {
private Set<BlankField> blankFields = new HashSet<BlankField>();
@CollectionOfElements
@Fetch(FetchMode.SUBSELECT)
@Enumerated(EnumType.ORDINAL)
@JoinTable(name = "blank_fields", joinColumns = { @JoinColumn(name = "ref_id") })
@Cascade(value = org.hibernate.annotations.CascadeType.DELETE_ORPHAN)
@Column(name = "blank_field", nullable = false)
@SQLInsert(sql = "INSERT INTO blank_fields(ref_id, blank_field, type) VALUES(?,?,1)") // used for insert
@Where(clause = "type=1") // used for query, if not @CollectionOfElements, such as @OneToMany, use @WhereJoinTable instead
public Set<BlankField> getBlankFields() {
return blankFields;
}
@SuppressWarnings("unused")
private void setBlankFields(Set<BlankField> blankFields) {
this.blankFields = blankFields;
}
}
當然還有其他的方式來實現(xiàn)上面的需求，上面采用的單表來記錄不同實體的associations（這兒是CollectionOfElements，并且返回的是Set<Enum>，不是Set<Embeddable>)，然后用'type'來區(qū)分不同的實體，這樣做的好處是：數(shù)據(jù)庫冗余少，易于擴展，對于新的實體，只需加一個type值，而不需更改數(shù)據(jù)庫表結(jié)構(gòu)。另外一種采用單表的方式是為每個實體增加新的字段，如"blank_fields": 'a_id', 'b_id', 'blank_field', a_id reference table_a (id), b_id reference table_b (id). 這樣在映射的時候更簡單，
對于A，映射為
@JoinTable(name = "blank_fields", joinColumns = { @JoinColumn(name = "a_id") })
對于B，映射為
@JoinTable(name = "blank_fields", joinColumns = { @JoinColumn(name = "b_id") })
這樣作的缺點是：帶來了數(shù)據(jù)庫冗余，對于blank_fields來講，任一條記錄，a_id和b_id中只有一個不為null。當多個實體共用這個表時，用上面的方法更合理，如果共用實體不多時，這種方法更方便。
The case to use One Hibernate Session Multiple Transactions:
each transaction would NOT affect others.
i.e., open multiple transactions on the same session, even though one transaction rolls back, other transactions can be committed. If one action fails, others should fail too, then we should use one transaction for all actions.
Note:
A rollback with a single Session will lead to that Session being cleared (through "Session.clear()").
So do lazy collections still work if the session is cleared? =>Not of any objects that you loaded up until the rollback. Only for new objects loaded afterwards.
We should load necessary objects to session for each transactional action to avoid LazyInitializationException, even if those objects are loaded before other forward transactional actions, since forward action may be rolled back and clear the session.
BTW, Hibernate Session.merge() is different with Session.update() by:
Item item2 = session.merge(item);
item2 == item; // false, item - DETACHED, item2 - PERSIST
session.update(item); // no return value, make item PERSIST
發(fā)生這種異常的case:
@Transactional
public void foo() {
try{
bar();
} catch (RuntimeException re) {
// caught but not throw further
}
}
@Transactional
public void bar() {
}
如果foo在調(diào)用bar的時候，bar拋出RuntimeException，Spring在bar return時將Transactional標記為Rollback only， 而foo捕獲了bar的RuntimeException，所以Spring將會commit foo的事務(wù)，但是foo和bar使用的是同一事務(wù)，因此在commit foo事務(wù)時，將會拋出UnexpectedRollbackException。注意：如果foo和bar在同一class中，不會出現(xiàn)這種情況，因為：
Since this mechanism is based on proxies, only 'external' method calls coming in through the proxy will be intercepted. This means that 'self-invocation', i.e. a method within the target object calling some other method of the target object, won't lead to an actual transaction at runtime even if the invoked method is marked with @Transactional!
可以通過配置log4j來debug Spring事務(wù)獲取情況：
To delve more into it I would turn up your log4j logging to debug and also look at what ExerciseModuleController is doing at line 91, e.g.: add a logger for org.springframework.transaction
這周被Quartz折騰了一番。
我們知道，Quartz采用JobDataMap實現(xiàn)向Job實例傳送配置屬性，正如Quartz官方文檔說的那樣：
How can I provide properties/configuration for a Job instance? The key is the JobDataMap, which is part of the JobDetail object.
The JobDataMap can be used to hold any number of (serializable) objects
which you wish to have made available to the job instance when it
executes.
JobDataMap map ＝ context.getJobDetail().getJobDataMap();
我們通過map向Job實例傳送多個objects，其中有一個是個bean，一個是基本類型。對于scheduled triggers，我們要求bean對于所有的序列都不變，包括其屬性，而基本類型可以在Job運行過程中改變，并影響下一個序列。實際情況是，對于下個序列，bean的屬性被上次的修改了，而基本類型卻維持第一次put到Map里面的值。正好和我們要求的相反。
受bean的影響，以為map里面包含的都是更新的對象，即每個序列里面的JobDetail是同一個對象，但是基本類型的結(jié)果否認了這一點。回頭重新翻閱了下Quartz的文檔：
Now, some additional notes about a job's state data (aka JobDataMap): A
Job instance can be defined as "stateful" or "non-stateful".
Non-stateful jobs only have their JobDataMap stored at the time they
are added to the scheduler. This means that any changes made to the
contents of the job data map during execution of the job will be lost,
and will not seen by the job the next time it executes.
Job有兩個子接口：StatefulJob and InterruptableJob，我們繼承的是InterruptableJob，或許Quartz應(yīng)該有個InterruptableStatefulJob。另外StatefulJob不支持并發(fā)執(zhí)行，和我們的需求不匹配，我們有自己的同步控制，Job必須可以并發(fā)運行。
然后查看了Quartz的相關(guān)源碼：
// RAMJobStore.storeJob
public void storeJob(SchedulingContext ctxt, JobDetail newJob,
boolean replaceExisting) throws ObjectAlreadyExistsException {
JobWrapper jw = new JobWrapper((JobDetail)newJob.clone()); // clone a new one
.
jobsByFQN.put(jw.key, jw);
}
也就是說，store里面放的是初始JobDetail的克隆，在序列運行完時，只有StatefulJob才會更新store里面的JobDetail：
// RAMJobStore.triggeredJobComplete
public void triggeredJobComplete(SchedulingContext ctxt, Trigger trigger,
JobDetail jobDetail, int triggerInstCode) {
JobWrapper jw = (JobWrapper) jobsByFQN.get(jobKey);
if (jw != null) {
JobDetail jd = jw.jobDetail;
if (jd.isStateful()) {
JobDataMap newData = jobDetail.getJobDataMap();
if (newData != null) {
newData = (JobDataMap)newData.clone();
newData.clearDirtyFlag();
}
jd.setJobDataMap(newData); // set to new one
}
}
然后，每次序列運行時所用的JobDetail，是存放在Store里面的克隆。
// RAMJobStore.retrieveJob
public JobDetail retrieveJob(SchedulingContext ctxt, String jobName,
String groupName) {
JobWrapper jw = (JobWrapper) jobsByFQN.get(JobWrapper.getJobNameKey(
jobName, groupName));
return (jw != null) ? (JobDetail)jw.jobDetail.clone() : null; // clone a new
}
問題很清楚了，存放在Store里面的JobDetail是初始對象的克隆，然后每個序列所用的JobDetail， 是Store里面的克隆，只有Stateful job，Store里面的JobDetail才更新。
最有Quartz里面使用的clone():
// Shallow copy the jobDataMap. Note that this means that if a user
// modifies a value object in this map from the cloned Trigger
// they will also be modifying this Trigger.
if (jobDataMap != null) {
copy.jobDataMap = (JobDataMap)jobDataMap.clone();
}
所以對于前面所講的，修改bean的屬性，會影響所有clone的對象，因此，我們可以將基本類型封裝到一個bean里面，map里面存放的是bean，然后通過修改bean的屬性，來達到影響下一個序列的目的。
From:
Web application design: the REST of the story
Key points:
- HTTP is a very general, scalable protocol. While most people only
think of HTTP as including the GET and POST methods used by typical
interactive browsers, HTTP actually defines several other methods that
can be used to manipulate resources in a properly designed application
(PUT and DELETE, for instance). The HTTP methods provide the verbs in a web interaction.
- Servers are completely stateless. Everything necessary to service a request is included by the client in the request.
- All application resources are described by unique URIs. Performing
a GET on a given URI returns a representation of that resource's state
(typically an HTML page, but possibly something else like XML). The
state of a resource is changed by performing a POST or PUT to the
resource URI. Thus, URIs name the nouns in a web interaction.
剛剛看CCTV實話實說，很有感觸，義烏技術(shù)職業(yè)學(xué)院給人眼前一亮，尤其是他們副院長的一番言論。
技術(shù)職業(yè)學(xué)院非得要升本科，本科非要成清華，義烏職業(yè)技術(shù)學(xué)院副院長評價當前高校的現(xiàn)狀，定位嚴重有問題，技術(shù)職業(yè)學(xué)院應(yīng)該培養(yǎng)應(yīng)用型人才，而清華就應(yīng)該培養(yǎng)研究性人才，兩種學(xué)校的定位不能一樣，培養(yǎng)方式，評判標準都應(yīng)該不同，而現(xiàn)在大多數(shù)高校的定位都一樣，這是不對的。個人非常贊同這個觀點，其實，這個觀點也可以應(yīng)用到我們這些剛開始工作的年輕人身上，消除浮躁，找準定位，然后沿著定位踏實做事，并且應(yīng)該采取相應(yīng)的評判標準，這個很重要。
1. RFC documents
2. SCEP operations
-
PKIOperation:
-
Certificate Enrollment - request: PKCSReq, response: PENDING, FAILURE, SUCCESS
-
Poll for Requester Initial Certificate - request: GetCertInitial, response: same as for PKCSReq
-
Certificate Access - request: GetCert, response: SUCCESS, FAILURE
-
CRL Access - request: GetCRL, response: raw DER encoded CRL
- Non-PKIOperation: clear HTTP Get
-
Get Certificate Authority Certificate - GetCACert, GetNextCACert, GetCACaps
-
Get Certificate Authority Certificate Chain - GetCACertChain
3. Request message formats for PKIOperation
- Common fields in all PKIOperation messages:
-
senderNonce
-
transactionID
- the SCEP message being transported(SCEP messages) -> encrypted using the public key of the recipient(Enveloped-data)
-> signed by one of certificates(Signed-data): the requester can generate a self-signed certificate, or the requester can use
a previously issued certificate, if the RA/CA supports the RENEWAL option.
- SCEP messages:
-
PKCSReq: PKCS#10
- GetCertInitial: messages for old versions of scep clients such as Sscep, AutoSscep, and Openscep, are different with draft-18
issuerAndSubject ::= SEQUENCE {
issuer Name,
subject Name
}
-
GetCert: an ASN.1 IssuerAndSerialNumber type, as specified in PKCS#7 Section 6.7
-
GetCRL: an ASN.1 IssuerAndSerialNumber type, as defined in PKCS#7 Section 6.7
--zz: http://forums13.itrc.hp.com/service/forums/questionanswer.do?admit=109447627+1230261484567+28353475&threadId=1213960
Question:
We are planning to calculate the percentage of physical memory utilised as below:
System Page Size: 4Kbytes
Memory: 5343128K (1562428K) real, 13632356K (3504760K) virtual, 66088K free Page# 1/604
Now the formula goes as below:
(free memory / actual active real memory) * 100
(66088/1562428) * 100 = 4.22 %
Please let us know if its the correct formula .
Mainly we are interested in RAM percentage utilised
Reply 1:
Red Hat/Centos v 5 take spare ram and use it for a buffer cache.
100%
memory allocation is pretty meaningless because allocation is almost
always near 100%. The 2.6.x kernel permits rapid re-allocation of
buffer to other purposes eliminating a performance penalty that you see
on an OS like HP-UX
I'm not thrilled with your formula because
it includes swap(virtual memory). If you start digging too deep into
virtual memory, your system start paging processes from memory to disk
and back again and slows down badly.
The formula is however essentially correct.
Reply 2:
Here, a quick example from the machine under my desk:
Mem: 3849216k total, 3648280k used, 200936k free, 210960k buffers
Swap: 4194296k total, 64k used, 4194232k free, 2986460k cached
If
the value of 'Swap used' is up (i.e. hundreds of megabytes), then
you've got an issue, but as you can see, it's only 64k here.
Your formula for how much memory is used is something along the lines of this:
(Used - (Buffers + Cached) / Total) * 100 = Used-by-programs%
(Free + Buffers + Cached / Total) * 100 = Free%
.. Roughly ..
昨天遇到個非常奇怪的bug：更新了一下后臺的代碼，結(jié)果每次點擊頁面都會導(dǎo)致servlet方法調(diào)用兩次，從而頁面報錯（邏輯上不讓調(diào)兩次 ），我們的前臺采用gwt，servlet engine采用tomcat，debug的時候，斷點放在servlet所調(diào)用的method上，結(jié)果invoke兩次，由此斷定，前臺代碼的問題（有點武斷哦
），然后負責前臺的同事debugging前臺的代碼，噼里啪啦半天。。。，說是前臺好像沒有調(diào)兩次（之所以用好像，是debugging時部分代碼走兩次，部分走一次），而我當時的想法是，后臺怎么操作，也不至于讓servlet調(diào)用兩次吧，所以我個人就認定是前臺邏輯導(dǎo)致重復(fù)rpc調(diào)用（gwt），但是這個bug在這兩天才出現(xiàn)的，從svn的歷史記錄來看，前臺代碼在這兩天基本沒什么改變，同事只好從svn上一個version接一個version的check，最后確定出兩個相鄰的versions，前一個能用，后一個出bug，這時我隱約感覺到是后臺的問題，但是還是想不明白，后臺的邏輯怎么就能讓前臺重復(fù)調(diào)用，非常不解，沒辦法，在同事的建議下，在servlet的那個method上加上一條debug信息，做了兩次試驗，一次是完整的代碼，一次是把method中調(diào)用后臺的接口注釋掉，結(jié)果從日志上看出，前一次試驗debug信息打印了兩次，后一次試驗debug只打印了一次，此時，確定是后臺邏輯影響了前臺的調(diào)用（此時，覺得走彎路了，為什么不早點做這個試驗，其實確定是前臺還是后臺的問題，只需要做這樣一個簡單的試驗。。。）。接下來，我思考的就是到底是什么在作怪呢，對比svn上的兩個版本，只有兩處可能的改動，一處是將return改成throw exception, 一處是調(diào)用了Thread.currentThread.interrupt()，我一個感覺是后者，注掉這句后，一切OK，呵呵，慶幸沒有先嘗試前者，要不改動很大，。。。
剛剛看了gwt的源碼，還沒找到問題的根源，我的觀點是，thread接收到interrupt信號時，會重復(fù)發(fā)送rpc調(diào)用，（呵呵，還沒確定）。。。
最近心情不是很好，上周三，父親的一次意外，給家里本來平靜的生活帶來了很大的波瀾，我也第一次感受到來自于家庭的壓力，由此帶來的一系列問題，一直縈繞著我，責任，responsibility，是這幾天我告誡自己最多的一個詞，是啊，該到了承受家庭責任的時候了。
父親的這次意外，揪住了全家人的心，我也更多的為兩位老人思考了，這兩天，老想起一句話：人只有經(jīng)歷的多了，才能成熟。我很喜歡類比，其實就跟我們做數(shù)學(xué)題一樣，看的多了，做的多了，考試的時候才能迎刃而解，什么東西，或許只有自己親身經(jīng)歷，才能體會其中的更多細節(jié)，才能激發(fā)更多的收獲。
祝福父親的身體早日康復(fù)，bless。。。
最近，時不時地回想自己這一路的教育經(jīng)歷，使得我越來越相信——命運！
總體來說，我自認為我這一路上走的太順利，缺少更多的經(jīng)歷，缺少一些該有的挫折！
但是，順利歸順利，在兩次作抉擇的時候，隨機的選擇決定現(xiàn)在的方向！一次當然是過獨木橋——高考，另一次是碩士入學(xué)時選擇導(dǎo)師！兩次選擇都很隨意，甚至于無意，尤其是第二次。第一次的隨意更多的是無知，而第二次的無意，卻源于自己的不適應(yīng)。隨意帶來了大學(xué)時代的混亂，無意卻給自己帶來了意外的收獲，人生無常，命運有數(shù)。
高考時，分數(shù)超出了自己的預(yù)料，志愿填的有些草率，一方面，是因為自己的年輕和無知，另一方面是由于周圍缺少必要的指點，填的很倉促，很隨意，非常的“高效”。正值00年高校擴招猖獗之時，我所填報的學(xué)校就是由三個學(xué)校合并而成，并且是在高考的前兩個月宣布合并的，其中有兩個合并之前不是一本，但是合并之后，肯定都是一本了。我當時選報了自動化這個專業(yè)，當時填的時候就因為高中班主任說了一聲：“現(xiàn)在自動化是一個很好的方向。”然而，此時命運開始現(xiàn)數(shù)，其中有兩個學(xué)校都有自動化這個專業(yè)，一個之前就是一本（合并后，稱之為‘校本部’，不知道這個是什么意思，或許我要去查查字典，好好揣測一下本部的含義。），另一個是三個學(xué)校中最差的一個，報道那天才知道有兩個自動化，但是由于剛合校，還沒來得及合并專業(yè)，當時就想，我該在哪個校區(qū)的自動化呢？最后隨著師長的指引，我被校車拉到了分校區(qū)，也就是那個最差的了，一路上，還在思索兩個自動化的分配算法，還是直到開學(xué)一個月以后，一次偶然的機會，才得知：兩個自動化是根據(jù)當時各省分數(shù)的交替順序分配，安徽省生源的第一名在本部，第二名在分校區(qū)，第三名本部，第四名分校區(qū)。。。。只能怪自己被動的排在了一個偶數(shù)的序位上，如果用一個函數(shù)來表示這個序位的話，其自變量的個數(shù)還是蠻多的，當年安徽省報考該校該專業(yè)的人生，你在這些人中的名次，另外還有，我還不太確定的因素，但是我能確定因素的存在。。。
后來，進一步得知，分校區(qū)的自動化之前沒有，我們是第一屆，當時在合校之前就已經(jīng)確定要新增這個專業(yè)，合的時候，各個學(xué)校的招生計劃都沒變，只是將三個計劃簡單的數(shù)學(xué)累加，現(xiàn)在看來，合校是多么的可笑，一個學(xué)校從任意層次可以一下成為中國最好的學(xué)校，只要清華愿意合并它，而合并后再很長一段時間，那個學(xué)校除了學(xué)生的層次提高之外，沒有任何的改變，教師還是那些教師，設(shè)施還是那些設(shè)施，思想還是那些思想，我不知道這可不可以稱之為赤裸裸的搶劫，它無視了那些默默地而踏踏實實前進的高校，助長了一些不公正的風氣，或許正應(yīng)了中國當時浮躁的社會氛圍。
就這樣在這度過了自己的三年大學(xué)時光，就在最后一個大學(xué)暑假之前，學(xué)校經(jīng)過三年的發(fā)展和磨合，決定將我們這個專業(yè)撤銷，統(tǒng)一合并到本部去，我們被迫搬回了第一天報道的地方，其實兩個自動化的方向是不一樣的，或許我們要慶幸，我們學(xué)習(xí)了兩個專業(yè)，在大學(xué)的四年中，但是或許，更多的人可能會埋怨兩個方向影響了自己的學(xué)習(xí)，其實，我想，大多數(shù)的人根本不在于什么方向，什么專業(yè)了，一個大框架的混亂，注定了最終的結(jié)果，就像當前的中國足球。。。
我要說的是，其實我在大學(xué)中過得很愉快，我認識了一批很好的同學(xué)，我經(jīng)歷了到目前為止最好的一段時光，雖然期間有很多遺憾，比如沒談一次戀愛。。。我想這段時光勢必會在我的記憶集合中占據(jù)非常重要的一塊。這里，我只不過是要論述命運有數(shù)，這樣的一個過程多少還是影響了我的人生軌跡。
下面要談?wù)撐业牡诙尉駬瘢T士時選擇導(dǎo)師。大學(xué)畢業(yè)時，我選擇了繼續(xù)就讀，一切都很順利，到了04年9月，我來到了新的學(xué)校，在合肥，這兒離家很近，因為我是安徽人，經(jīng)歷了大學(xué)時回家的艱辛，再加上我又是個比較戀家的人。剛?cè)胄＃陀龅搅艘粋€。。。。
明天繼續(xù)。。。。