ctrl+space
ctrl+t
ctrl+k
ctrl+f8/f9/f10
alt+shift+x , t/j
alt+shift+d , t/j
Command:
cd -
tab
ctrl+a/e
ctrl+u/k/w
Vim
shift+g
m+'mark'
`+'mark'
. (repeat)
]]>
]]>
2 transaction features:
ACID (atomicity, consistency, isolation, durability)
3 java spec
JTA, JTS
1
interface javax.transaction.TransactionManager
2
{
3
public abstract void begin();
4public abstract void commit();
5public abstract int getStatus();
6public abstract Transaction getTransaction();
7public void resume(Transaction tobj);
8public abstract void rollback();
9public abstract void setRollbackOnly();
10public abstract void setTransactionTimeout(intseconds);
11public abstract Transaction suspend() ;
12
}
interface javax.transaction.TransactionManager2
{
3
public abstract void begin();4
public abstract void commit();5
public abstract int getStatus();6
public abstract Transaction getTransaction();7
public void resume(Transaction tobj);8
public abstract void rollback();9
public abstract void setRollbackOnly();10
public abstract void setTransactionTimeout(intseconds);11
public abstract Transaction suspend() ;12
}4 Common XAResource
JDBC 2.0:
A JDBC driver that supports distributed transactions implements the javax.transaction.xa.XAResource interface, the javax.sql.XAConnectioninterface, and the javax.sql.XADataSource interface.
JMS 1.0:
a JMS provider javax.transaction.xa.XAResource interface, the implements the javax.jms.XAConnection and the javax.jms.XASession interface.
5 Common TransactionManager
5.1 EJB Transaction Options:
NotSupported
If the method is called within a transaction, this transaction is suspended during the time of the method execution.
Required
If the method is called within a transaction, the method is executed in the scope of this transaction; otherwise, a new transaction is started for the execution of the method and committed before the method result is sent to the caller.
RequiresNew
The method will always be executed within the scope of a new transaction. The new transaction is started for the execution of the method, and committed before the method result is sent to the caller. If the method is called within a transaction, this transaction is suspended before the new one is started and resumed when the new transaction has completed.
Mandatory
The method should always be called within the scope of a transaction, else the container will throw the TransactionRequired exception.
Supports
The method is invoked within the caller transaction scope; if the caller does not have an associated transaction, the method is invoked without a transaction scope.
Never
The client is required to call the bean without any transaction context; if it is not the case, a java.rmi.RemoteException is thrown by the container.
5.2 Spring transaction:
Transaction isolation: The degree of isolation this transaction has from the work of other transactions. For example, can this transaction see uncommitted writes from other transactions? avaliable options:
ISOLATION_DEFAULT
ISOLATION_READ_UNCOMMITTED
ISOLATION_READ_COMMITTED
ISOLATION_REPEATABLE_READ
ISOLATION_SERIALIZABLE
Transaction propagation: Normally all code executed within a transaction scope will run in that transaction. However, there are several options specifying behavior if a transactional method is executed when a transaction context already exists: For example, simply running in the existing transaction (the most common case); or suspending the existing transaction and creating a new transaction. Spring offers the transaction propagation options familiar from EJB CMT. avaliable options:
PROPAGATION_MANDATORY
PROPAGATION_NESTED
PROPAGATION_NEVER
PROPAGATION_NOT_SUPPORTED
PROPAGATION_REQUIRED
PROPAGATION_REQUIRES_NEW
PROPAGATION_SUPPORTS
Transaction timeout: How long this transaction may run before timing out (automatically being rolled back by the underlying transaction infrastructure).
Read-only status: A read-only transaction does not modify any data. Read-only transactions can be a useful optimization in some cases (such as when using Hibernate).
6 transaction for web service
Protocol specifications:
WS-Transaction
OASIS Business Transaction Protocol (BTP)
Java API
JAXTX (JSR-156)
]]>
1 //wrong: all function refer to global variable i=10
2 var fn_list=[];
3 for(var i=0;i<10;i++){
4 var _tempFn =function(){
5 return i;
6 }
7 fn_list.push(_tempFn);
8 }
9 //right: every function refer to its closure scope variable a
10 var fn_list=[];
11 for(var i=0;i<10;i++){
12 var _tempFn =function(a){
13 return function(){
14 return a;
15 };
16 }
17 fn_list.push(_tempFn(i));
18 }
19
2 var fn_list=[];
3 for(var i=0;i<10;i++){
4 var _tempFn =function(){
5 return i;
6 }
7 fn_list.push(_tempFn);
8 }
9 //right: every function refer to its closure scope variable a
10 var fn_list=[];
11 for(var i=0;i<10;i++){
12 var _tempFn =function(a){
13 return function(){
14 return a;
15 };
16 }
17 fn_list.push(_tempFn(i));
18 }
19
Java里也有两个让初学者容易淆的概念Qnest class and inner class?br /> nest class是static inner class,
而inner class是no-static inner class。没有ؓ什么，sun是q么定义的?br /> q是上面得例子，创徏10个对象，每个对象的getValue接口依次q回0-9.
1 public class Test {
2 private int noStaticValue;
3 private static int staticValue;
4
5 public Test(int noSV, int sv) {
6 this.noStaticValue = noSV;
7 this.staticValue = sv;
8 }
9
10 public Test(int noSV) {
11 this.noStaticValue = noSV;
12 }
13
14 interface valueHolder {
15 int getValue();
16 }
17
18 class innerClass implements valueHolder {
19 public int getValue() {
20 return noStaticValue;
21 }
22 }
23
24 static class nestClass implements valueHolder {
25 public nestClass(int i) {
26 staticValue = i;
27 }
28
29 public int getValue() {
30 return staticValue;
31 }
32 }
33
34 public static void main(String[] args) {
35 Test context1 = new Test(0, 0);
36 valueHolder[] list = new valueHolder[10];
37 for (int i = 0; i < 10; i++) {
38 list[i] = new Test.nestClass(i);
39 }
40 for (valueHolder obj : list) {
41 System.out.println(obj.getValue());// always print 9
42 }
43 for (int i = 0; i < 10; i++) {
44 list[i] = new Test(i).new innerClass();
45 }
46 for (valueHolder obj : list) {
47 System.out.println(obj.getValue());// print 0-9
48 }
49 }
50 }
可见用inner class可以模拟closure的特性，是q行时定义class的某些状态?br />
inner class和nest class之间的区别就是后者是静态类。前者必通过wrap class的实例来调用new,e.g. new Test().new innerClass?br />
因ؓnest class是静态类Q所以可以添加static member 或者static method,而inner class 不行?br />
匿名内部cLinner class的一U特DŞ式，所以也不能dstatic member 或者static method?br />
2 private int noStaticValue;
3 private static int staticValue;
4
5 public Test(int noSV, int sv) {
6 this.noStaticValue = noSV;
7 this.staticValue = sv;
8 }
9
10 public Test(int noSV) {
11 this.noStaticValue = noSV;
12 }
13
14 interface valueHolder {
15 int getValue();
16 }
17
18 class innerClass implements valueHolder {
19 public int getValue() {
20 return noStaticValue;
21 }
22 }
23
24 static class nestClass implements valueHolder {
25 public nestClass(int i) {
26 staticValue = i;
27 }
28
29 public int getValue() {
30 return staticValue;
31 }
32 }
33
34 public static void main(String[] args) {
35 Test context1 = new Test(0, 0);
36 valueHolder[] list = new valueHolder[10];
37 for (int i = 0; i < 10; i++) {
38 list[i] = new Test.nestClass(i);
39 }
40 for (valueHolder obj : list) {
41 System.out.println(obj.getValue());// always print 9
42 }
43 for (int i = 0; i < 10; i++) {
44 list[i] = new Test(i).new innerClass();
45 }
46 for (valueHolder obj : list) {
47 System.out.println(obj.getValue());// print 0-9
48 }
49 }
50 }
]]>
自发和专_也许能在中短期l持动力Q但是长期下去，当我们不知道自己Z么工作的时候，动力也会衰竭。目标性要求目标不能太低而没有成感Q或者太高而很难达到。最好的目标是比你现在的成就更高Q且需要一定的努力才能辑ֈ?br /> Drive: The Surprising Truth About What Motivates Us
]]>
]]>
Cache的目的是Z以空间换旉Q一ơ计结果ؓ多次重用?br /> I间可以是实时内存空间、持久化的硬盘空间。时间可以是q算旉、连接时间、传输时间等?br />
Cache可以分ؓLocalCache和DistributedCache?br /> 最单的LocalCache可以通过l护一个ConcurrentHashMap实现?br /> ~点是：
1Q内存有限，Ҏout of memory Q定期清除？持久化？Q?br /> 2, 需要对全map做concurrencyl护Q粗_度的锁定争用会影响性能Q树l构l护Q）
在一个专业的企业U应用中Qcache除了高性能和线E安全的要求Q还要支持事务、高可用性、持久化、容错、集同步等?br /> JBossCache是一个典型的企业Ucache实现Q他采用树结构且支持集群和事务特性?br /> 虽然JBossCacheq把牛刀也可以在standalone的JS2E应用中用来杀鸡，但我们应该更兛_用他在集环境中怎么杀牛?br /> JBossCache分ؓ非集模?Local)和集模式?br /> 集群模式Ҏ实现{略又分为replication和invalidation?br /> 1 replicationQ通过拯改变的cache对象来保证与集群中其他cache同步。replication又可l分为同步replication和异步repliation两种Q异步replication较快,put以后马上q回Q但是replication出错了，事务q是完成了不回回滚。同步replication要花旉{待其他的cache完成replication的通知才能l束?br />
2 invalidation: 如果cache状态改变，仅仅是给其他cache发个通知Q收到通知的cache把脏数据清除掉。invalidation也可分ؓ同步和异步两U，区别是发送通知的广播方式一个是同步一个是异步?br />
在jboss cluster中，我们最好通过MBean来部|jboss cache。这样又几个好处Q?br /> 1QJBoss NS支持Cluster
我们可以通过JBoss NamingService来访问cache。如果在local NS中查不到cacheQjbss NSq会Lcluster中其他的cache?br /> 2Q利用MBean的特?br /> 通过CacheMBean, 我们可以方便的管理Cache ServiceQ实时的启动、停止或者改变一些配|，q可以监控到一些cachel计数据?br /> 3Q利?a id="d0e1230">microcontainer的特?br />
我们可以通过配置XML文g来完成cache相关的所有对象声明?/code>而言之，是利用java reflection和AOP的技术就不用写声明cache的代码了?br />
<?xml version="1.0" encoding="UTF-8"?>
<deployment xmlns="urn:jboss:bean-deployer:2.0">
<!-- First we create a Configuration object for the cache -->
<bean name="ExampleCacheConfig"
class="org.jboss.cache.config.Configuration">
build up the Configuration</bean>
<!-- Factory to build the Cache. -->
<bean name="DefaultCacheFactory" class="org.jboss.cache.DefaultCacheFactory">
<constructor factoryClass="org.jboss.cache.DefaultCacheFactory"
factoryMethod="getInstance" />
</bean>
<!-- The cache itself -->
<bean name="ExampleCache" class="org.jboss.cache.CacheImpl">
<constructor factoryMethod="createnewInstance">
<factory bean="DefaultCacheFactory"/>
<parameter><inject bean="ExampleCacheConfig"/></parameter>
<parameter>false</parameter>
</constructor>
</bean>
<!-- JMX Management -->
<bean name="ExampleCacheJmxWrapper" class="org.jboss.cache.jmx.CacheJmxWrapper">
<annotation>@org.jboss.aop.microcontainer.aspects.jmx.JMX(name="jboss.cache:service=ExampleTreeCache",
exposedInterface=org.jboss.cache.jmx.CacheJmxWrapperMBean.class,
registerDirectly=true)</annotation>
<constructor>
<parameter><inject bean="ExampleCache"/></parameter>
</constructor>
</bean>
</deployment>
后记Q?br /> 1Qjboss cache的naga版中Q采?a >Multi-versioned concurrency control来实现ƈ发。下ơ再从中ȝ一下多U程的学习?br /> 2Qjboss cache通过l合visitor pattern和command patternQ把对cache node的操作与讉K从中隔离出来Q不用改变或者扩展node对象可以添加新的node行ؓ。也是开闭原则。下ơ再从中ȝ一下几U设计模式的l典应用?br />
]]>