面朝大海,春暖花开

马上要做新项目了，项目不大，准备用ajax来练练手，HOHO!

今天在网上闲逛，发现了一本好书，关于JAVA和TDD的，内容介绍如下：

Master Java 5.0 and TDD Together: Build More Robust, Professional Software

Master Java 5.0, object-oriented design, and Test-Driven Development (TDD) by learning them together. Agile Java weaves all three into a single coherent approach to building professional, robust software systems. Jeff Langr shows exactly how Java and TDD integrate throughout the entire development lifecycle, helping you leverage today's fastest, most efficient development techniques from the very outset.

Langr writes for every programmer, even those with little or no experience with Java, object-oriented development, or agile methods. He shows how to translate oral requirements into practical tests, and then how to use those tests to create reliable, high-performance Java code that solves real problems. Agile Java doesn't just teach the core features of the Java language: it presents coded test examples for each of them. This TDD-centered approach doesn't just lead to better code: it provides powerful feedback that will help you learn Java far more rapidly. The use of TDD as a learning mechanism is a landmark departure from conventional teaching techniques.

• Presents an expert overview of TDD and agile programming techniques from the Java developer's perspective

• Brings together practical best practices for Java, TDD, and OO design

• Walks through setting up Java 5.0 and writing your first program

• Covers all the basics, including strings, packages, and more

• Simplifies object-oriented concepts, including classes, interfaces, polymorphism, and inheritance

• Contains detailed chapters on exceptions and logging, math, I/O, reflection, multithreading, and Swing

• Offers seamlessly-integrated explanations of Java 5.0's key innovations, from generics to annotations

• Shows how TDD impacts system design, and vice versa

• Complements any agile or traditional methodology, including Extreme Programming (XP)

E文不算太难，一般都应该可以看懂，为什么好书都是老外写的呢？
我想把书传上来，但是.Text对文件的大小好象是有限制，书的名字叫
Agile Java Crafting Code with Test-Driven Development，想要的同学可以留下EMAIL

很早就听说过Castle的大名了，但是一直没有时间去研究。一方面也是自己的惰性，另一方面也关于Castle的分析文章太少了。但是不管怎么说，面对这这么优秀的项目没有一睹芳容，真是。现在好了，在博客园找到了一个关于Castle的系列文章，先收藏个连接，51在休息的空隙，还可以抽出点时间好好研究好东东，。
http://www.cnblogs.com/Terrylee/archive/2006/04/28/387503.html

近来很忙，一直没写 blog 了，今天晚上有点时间，听了节 MSDN 上面的一节 webCast ，讲的就是 Proxy 模式，本就就是这节课的笔记。

学习设计模式也有段时间了，很早也见过 Proxy 模式的，记得最开始接触 Proxy 模式还是在著名的 JIVE 论坛（ JIVE 中用 Proxy 来做权限控制）。今天算是一遍复习吧。

对复杂的软件系统，人们常常用的一种处理手法是在系统增加一层间接层，得到对系统灵活的、满足特殊要求的解决方案。

使用 Proxy 模式的动机：在 OO 的开发过程中，某些对象的开销很大（如： new 的开销大、某些对象因为安全的原因不能被客户直接的调用等），如果直接操作这些对象会破坏系统结构。那么，我们就用代理对象来控制对象的访问。

例子，   一个常见的 HR 系统：

现在要求把 Employee 做成 webService ， HR 系统通过 webService 来调用 Employee 对象，代码修改如下：

Proxy 使用的要点：

1 、“增加一层间接层”，是软件系统中常用的手段之一。

2 、具体的实现中， Proxy 有很大差别，有的是简单的“ copy-on-write ”，有的是对组件模块的抽象代理。在 JAVA 中常见的 SSH 架构模式中（ struts+spring+hibernate ）中，我们可以把 spring 所在的服务层看成对 hiberate 的代理。

具体的实现可以参考 .NET 中的 WebService 的实现。

Copy-on-write 技术

sb1.replace("H","L"); 系统做的动作是， sb1 的代理对象先拷贝 ”Hello” 字符串，然后用“ L ”替换“ H ”， sb1 的代理对象重新指向新的对象。

一、           数据库事务概念

数据库事务的特征： ACID

Atomic （原子性）、 Consistency （一致性）、 Isolation （隔离性）和 Durability （持久性）。 DBMS 用日志来保证数据的原子性、一致性和持久性；用锁的机制来保证数据的隔离性。

二、           事务的边界

数据库支持 2 种事务模式：自动提交和手动提交。

JDBC API 的事务边界

Hibernate API 声明事务边界

Session session  =  factory.openSession();
Transaction tx;
try  
{
    tx  =  session.beginTransaction();  // 开始事务
     // 执行操作
    。。。。。
    
    tx.commit();
}
catch  (Exception e)
{
     if  (tx != null )
     {
        tx.rollback();
    }
}
finally
{
    session.close();
}

注：一个 session 可以对应多个事务，但是推荐的做法是一个 session 对应一个事务。

三、            多事务的并发问题

当多个事务同时访问相同的数据的时候，程序如果没有采取适当的隔离措施，就会发生数据库的并发问题。常见的并发问题有：

第一类丢失更新：撤消事务的时候，把其他的事务已经提交的数据给覆盖了；

脏读；读了没有提交的数据；

虚读：一个事务读到另外一个事务已经提交的新插入的数据；

不可重复读：一个事务读到另外一个事务已经提交的更新的数据；

第二类丢失更新：一个事务覆盖另外一个事务已经提交的更新数据。 
四、           锁

一般地，大型的 DBMS 都会自动的管理锁定机制，但是在对数据的安全性、完整性和一致性有特殊要求的地方，可以由事务本身来管理琐的机制。

有一点要关注的是：锁的粒度越大，隔离性越好，并发性越差。

按照锁的程度来分有：

共享锁：用读操作，非独占的，其他事务可以读，但是不能更新，并发性好；

独占锁：用与 insert update 和 delete 等语句，其他事务不能读，也不能改，并发性差；

更新锁：执行 update 的时候，加锁。

死琐：多是事务分别锁定了一个资源，又请求锁定对方已经锁定的资源，就造成了请求环。

降低死锁的最好办法是使用短事务。

五、            数据库的事务隔离级别

数据库提供 4 种事务隔离级别：

Serializable ：串行化；（隔离级别最高） 1

Repeatable Read ：可重复读； 2

Read Commited ：读已提交数据； 4

Read Uncommited ：读未提交数据；（隔离级别最低） 8

Hiberate 中的隔离级别的设置

在 Hibernate 的配置文件中 hibernate.connection.isolation=2

六、            悲观锁和乐观琐

从应用程序的角度来看，锁分为悲观锁和乐观锁。

悲观锁：显示的为程序加锁，但是降低并发性。

Select ……. For update;

在 Hibernate 中的代码

Session.get(Account.class,net Long(1),LockMode.UPGRADE) ； // 程序采用悲观锁

乐观锁：依靠 DBMS 来管理锁，程序依靠版本控制来避免并发问题。

在对象 - 关系映射的文件中，用 <version> 或者 <timestamp> 可以管理并发。乐观琐比悲观琐有更好的并发性，优先考虑乐观琐。  

     摘要: 1. 你们的项目组使用源代码管理工具了么？     应该用。 VSS 、 CVS 、 PVCS 、 ClearCase 、 CCC/Harvest 、 FireFly 都可以。我的选择是 VSS 。 ...  阅读全文

在JAVA的老巢找到的这本书，不用多说了，这本书就是JAVA权威了，SUN提供了PDF下载和在线浏览：http://java.sun.com/docs/books/jls/

1.长相不令人讨厌，如果长得不好，就让自己有才气；如果才气也没有，那就总是微笑。
 　　
 　　2.气质是关键。如果时尚学不好，宁愿纯朴。
 　　
 　　3.与人握手时，可多握一会儿。真诚是宝。
 　　
 　　4.不必什么都用“我”做主语。
 　　
 　　5.不要向朋友借钱。
 　　
 　　6.不要“逼”客人看你的家庭相册。
 　　
 　　7.与人打“的”时，请抢先坐在司机旁。
 　　
 　　8.坚持在背后说别人好话，别担心这好话传不到当事人耳朵里。
 　　
 　　9.有人在你面前说某人坏话时，你只微笑。
 　　
 　　10.自己开小车，不要特地停下来和一个骑自行车的同事打招呼。人家会以为你在炫耀。
 　　
 　　11.同事生病时，去探望他。很自然地坐在他病床上，回家再认真洗手。
 　　
 　　12.不要把过去的事全让人知道。
 　　
 　　13.尊重不喜欢你的人。
 　　
 　　14.对事不对人；或对事无情，对人要有情；或做人第一，做事其次。
 　　
 　　15.自我批评总能让人相信，自我表扬则不然。
 　　
 　　16.没有什么东西比围观者们更能提高你的保龄球的成绩了。所以，平常不要吝惜你的喝彩声。
 　　
 　　17.不要把别人的好，视为理所当然。要知道感恩。
 　　
 　　18.榕树上的“八哥”在讲，只讲不听，结果乱成一团。学会聆听。
 　　
 　　19.尊重传达室里的师傅及搞卫生的阿姨。
 　　
 　　20.说话的时候记得常用“我们”开头。
 　　
 　　21.为每一位上台唱歌的人鼓掌。
 　　
 　　22.有时要明知故问：你的钻戒很贵吧！有时，即使想问也不能问，比如：你多大了？
 　　
 　　23.话多必失，人多的场合少说话。
 　　
 　　24.把未出口的“不”改成：“这需要时间”、“我尽力”、“我不确定”、“当我决定后，会给你打电话”……
 　　
 　　25.不要期望所有人都喜欢你，那是不可能的，让大多数人喜欢就是成功的表现。
 　　
 　　26.当然，自己要喜欢自己。 　　
 　　
 　　ps:27.如果你在表演或者是讲演的时候，如果只要有一个人在听也要用心的继续下去，即使没有人喝采也要演，因为这是你成功的道路，是你成功的摇篮，你不要看的人成功，而是要你成功。
 　　
 　　28.如果你看到一个贴子还值得一看的话，那么你一定要回复，因为你的回复会给人继续前进的勇气，会给人很大的激励，同时也会让人感激你!

Hibernate 提供了 3 种检索策略：

l        延迟检索；

l        立即检索；

l        迫切左外连接；

Hibernate 提供 2 种方式来确定检索策略，一中是在配置文件当中，另外一种是在程序种设置。当然，如果你在程序中设置了检索策略，那么你在配置文件中的设置也就无效了。另外的一种情况是 HQL 会忽略配置文件的设置，而总是采用迫切左外连接。

一、 类级别的检索

可以选择的检索策略是立即检索和延迟检索，默认的是立即检索。用配置文件中的 <class> 节点的 lazy 来控制。

注意：不管你在配置 class 的 lazy 是 true 还是 false ，对 get() 和 create Criteria () 方法都不起作用，只有对 load() 方法起作用。

当你使用的检索策略是 lazy 的时候，当你执行

Customer customer = (Customer)session.load(Customer.class,new Long(1));

的时候， Hibernate 不从数据库检索数据，而只是产生一个代理类，只有当你执行

Customer.getName();

的时候， Hibernate 才到数据库取数据。所以，如下的代码是会被抛出异常的：

get() 方法总是用的立即检索，如果和它相关联的类也是用的立即检索，那么也会把相关联的数据也检索出来。

二、 一对和多对多关联检索

一般地，为了有减少对数据库的访问，我们往往用延迟检索的策略。所以，我们优先使用如下方式；

<set class=”order” inverse=”true’ lazy=”true” >

但是，我们在检索“多”的一方的时候， Hibernate 不能为我们产生代理类。由此，我们就要用 betch-size 的配置来减少 SQL 语句。

当我们使用 outer-join 属性的时候，我们就没有必要使用 lazy 属性了。 Outer-join 会一次将“一”方和与之相关的“多”方用左外连接的方式检索出来。

Session session = sessionFactory.openSession();

                     Transaction tx = null;

                     tx = session.beginTransaction();

                    Customer customer = (Customer)session.get(Customer.class,new Long(1));

产生的 SQL 语句如下：

Hibernate: select customer0_.ID as ID1_, customer0_.NAME as NAME2_1_, orders1_.CUSTOMER_ID as CUSTOMER3_3_, orders1_.ID as ID3_, orders1_.ID as ID0_, orders1_.ORDER_NUMBER as ORDER2_1_0_, orders1_.CUSTOMER_ID as CUSTOMER3_1_0_ from sampledb.customers customer0_ left outer join sampledb.orders orders1_ on customer0_.ID=orders1_.CUSTOMER_ID where customer0_.ID=?

本文是《 JAVA 编程思想》第四章的读书笔记

 

一、 用构造函数初始化

1．1、   函数的签名和返回值

构造函数可以通过不同的函数签名来进行重载。构造函数没有返回值，这和返回值为 void 的是不同的

1．2、   构造函数的重载

如何区分构造函数的不同呢，用不同的函数签名。函数签名的顺序不同都可以，但是这样的编程风格是不好的。

函数的签名会上升转型（当没有合适的函数签名出现的时候），但是不会窄化转型，你必须要显示的进行强制类型转换。

不能以 return value 的不同作为重载的标准。

当程序提供了构造函数以后，系统就不在提供默认的构造函数了。

This 关键字指的是当前对象，有了 this 后，可以在构造函数中以如下的方式调用

1．3、   Static 的含义

你无法在 static 函数中调用 non-static 函数，但是你可以在 non-static 中调用 static 函数。

二、 类的清理

JAVA 的垃圾回收机制只能回收 new 出来的对象，但是你的对象不是 new 出来的而获得的“特殊”内存，那么 JAVA 的垃圾回收就不能处理，这样就必须用 finalize() 函数来释放你的“特殊”内存。

JAVA 的清理方式是先调用你的 finalize() ，然后在下次垃圾回收的时候来清理你的“特殊”内存。

关键的三句话：

垃圾回收不等于析构；

你的对象可能不被回收；

垃圾回收动作只回收内存。

用 System.gc() 可以用来强迫终结动作的发生