随笔档案(496)

UltraEdit 固然是个优秀的编辑器，但是安装它后，在IE中选”查看源文件“码的时候，默认不是Notepad了！

而我常常只是为了搜寻一下某些关键字... ...

一个简短的“查看源文件“的动作就要开启一个UltraEdit，感觉就是杀鸡用牛刀！

找了一下，修正的方法如下，修改一下注册表：

找到这里：

HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Internet Explorer\View Source Editor\Editor Name

把默认的编辑器修改为：

C:\WINNT\NOTEPAD.EXE (for Windows 2000)
C:\WINDOWS\NOTEPAD.EXE (for Windows XP/2003)

这样就可以了！ 　　针对在编程过程中，大量使用“System.out.println(); ”语句进行调试，监测，给在后期部署及维护的过程中增加了一定难度，特编写本文档，规范JAVA控制台输出的函数的使用，增强代码的可维护性。

　　一般在编码过程中，为了检测代码逻辑或显示计算结果等，我们需要在控制台中打印一些信息来确定代码的正确性，或查看程序运行状态。通常情况下，在JAVA中会直接使用函数“System.out.println()”或“System.out.print()”来向控制台输出信息。这些函数可能会出现在代码的任何位置，在代码行数不断增多及随着时间的推移，这些函数也会造成许多冗余的输出，且对其程序本身的功能无任何用处，当然也不会影响到具体功能的实现。但是在实际部署或进行后期维护时，当有些输出到控制台的信息影响到你，为你的部署及维护带来许多不便时，你想删除某个信息的输出却不是那么容易，就得在代码中一个一个去查找他们的位置，手动删除每一个不必要的“System.out.prin…”。

　　其实要改变手动查找“System.out.prin…” 的烦恼也很简单，只要简单的遵循如下规则即可。

＜!--[if !supportLists]--＞1. ＜!--[endif]--＞编写一个JAVA类“XXXUtil ”，在里面设置一个布尔型的成员变量，再写一个方法来替换掉所有的“System.out.prin…”就行了！

＜!--[if !supportLists]--＞2. ＜!--[endif]--＞将此JAVA类放入你的工程中。


KooeUtil.java：

public class KooeUtil {

// 该变量值也可以通过文件获取。

public static Boolean isDebug = false;

public static void echo (String str) {

if (isDebug) {

System.out.println(str);

}

}

}

＜!--[if !vml]--＞ ＜!--[endif]--＞
具体实现：

public class XXXUtil {

// 该变量值也可以通过文件获取。


public static Boolean isDebug = false;


public static void echo (String str) {

if (isDebug) { System.out.println(str); }

}

}

　　将以上代码加入你的工程，然后将所有的“System.out.println”替换成“XXXUtil .echo”即可。

　　这样我们就可以简单的通过设置isDebug值来控制工程中所有的输出函数是否输出，使程序更具有可维护性。 Jython 2.2 发布了，这次发布的2.2版本实现了 Python 2.2 以及 2.3。

Jython 是Python 的Java实现。无缝地结合了Java类与Python，使用户能以Python语言的语法编写在Java虚拟机上运行的程序。

这次版本的新特性包括：

new-style classes
Java Collections integration
PEP 302 implementation
iterators
generators
__future__ division
support for running on JDK1.5 and 1.6
new installer
a significant number of features to bring Jython in line with CPython


官方站点：
http://www.jython.org/

     合作。不要随便与人合作，与人合作要考虑好利与弊。如果有想法尽快去干，一个人努力地干，卖命地干。干到差不了，有资本了，可以与人短期性的合作。与人合作目标要明确。

     努力。工作要努力，随随便便过日子过四五年也是过，稍微努力地过四五年也是过，努力地过四五年也是过，何不努力好好地干。如果努力地过好四五年，这对我们以后的人生很有帮助。

     吃苦耐劳。不要怕吃苦。在创业阶段，我们要的是名气，是经验，有时候在保本的情况下可以以低价策略来和别人竞争。我们出卖的是点脑力活，力气活，年轻人，睡一觉起来什么都恢复了。

     目标。生活要有目标，不仅仅是事业(赚钱)的目标，其他方面也要有目标，如爱情方面的目标、健康方面的目标、家庭方面的目标。各个目标都要重视。只赚了钱，不算人生的成功。

     虚心学习。多与比自己大的人(长辈)、成功人士交流学习，要虚心听取、认真分析他们的意见和建议，以免自己以后走弯路。

     了解社会。多了解社会、多实践、多分析某些社会现象的因果厉害关系。认真分析身边发生的某些事情。正视社会的阴暗面。分析社会上某些不良风气，不要清高自傲，也不要随波逐流。某些时候办事情，也需要这方面的帮助。

     自由。出来外面做事情，关键是自由、愉快，能学到知识。每走一步都要分析，不要因某一小点利益限制了自己的自由。

     计划。给自己定一个五年计划、十年规划。每季度做什么事情、每个月做什么事情，甚至每天做什么事情，有个计划，有个目标比较好。不要每天昏昏恶恶。几年后你会发现，几年来一直没有目标，什么也没有做成。

     胆量。你是工人的子弟，或是农民的儿子，难免思想狭隘。不要盲目、盲从，也不要胆小怕事。多锻炼，大胆去做事情，只要不违法。大胆去做，即使失败了，也为下次积累了经验。“商场如战场”，这句话一点不假。想想，在战场上，不是你死就是我亡。

     谋略。人生活在社会上，就是要用自己的智慧谋略和别人斗智斗勇。即使有时你不想和别人斗，别人也要和你争。既然不能退让，何不争一争。古往今来，某些人的成功，不是电视小说里说的那么偶然，有其必然性。生活中不玩点小技巧(犯法的不做、害人的不做)，哪能那么容易就成功.

     不要害怕贫穷。也许你家里没有几十万上百万元，大胆地去做事情，不要怕贫穷。即使我们的事情做失败了，我们大不了回到起点，还是穷人。

     学习。不断充实自己，学习新的知识，多学点技能，为以后作准备，也可作为以后的娱乐消遣。如：驾驶技术、炒菜做饭、写文章等。

     惜时。如果以*都做了，我估计你的时间过得很快。我常听某某人说：“这一辈子，就象昨天今天一样。”毛泽东说：“天地转，光阴迫。一万年太久，只争朝夕。”“三十八年过去弹指一挥间”。不要因碌碌无为而悔恨!

     请记住，以上忠告如果能够做到了，你做什么都一定能够成功！

童心

——无论你有多老，你的心不能变老

音乐

——如果没有音乐，你的人生将会乏味无比

浪漫

——偶尔浪漫一下，那种感觉就像一只小鸟在空中飞翔吧

优雅

——何必要装的粗鲁呢，优雅一点总是好的

沉思

——在你有一肚子火要发之前，先给自己10分钟沉思一会儿

驰骋

——如果真的累了，就变成一只蝴蝶逃开一会吧，不要让自己太累

纯洁

——现在的社会已经够混浊了，纯洁真是不容易做到呢

勇敢

——做个勇敢的精灵，不惧狂风会撕碎你的翅膀

可爱

——我相信，你会因为可爱而美丽

1、word的恢复

方法1、点开始--运行，输入"winword /a"(不含引号)
       回车后会启动word，所有界面和设置都恢复了初始状态,简单吧!

方法2、首先关闭Word程序，然后进入Word程序的默认模板所在的目录Microsoft\Templates，将名为Normal. Dot的文件重命

名为其他的文件名，然后再启动Word，其所有设置与界面已经恢复到刚刚安装完毕后的状态。
（C:\Documents and Settings\登录用户名\Application Data\Microsoft\Templates，其中Application Data文件夹为隐含

文件夹）

2、excel的恢复
删除 Excel11.xlb(Excel2003) 这个档后重新执行Excel,就会恢复Excel预设的菜单设定
Excel Xp 的位置:C:\Documents and Settings\登录用户名\Application Data\Microsoft\Excel

注：建议用搜寻档案 *.xlb(Normal. Dot)的方式

//ArrayList
{
ArrayList arraylist=new ArrayList();
arraylist.add(0,"end");//指定索引加入值
//需注意的是，如果现有2个值，我加入索引为5的那么就会出现异常
for(int i=0;i<2;i++){
arraylist.add(i,String.valueOf(i));
}
System.out.println("ArrayList:");
for(int i=0;i<arraylist.size();i++){
System.out.print(arraylist.get(i)+";");
}
arraylist.add("0");//直接加入值到ArrayList的最后
arraylist.add("0");
System.out.print("\nArrayList\'s lastIndexOf(\"0\") is "+arraylist.lastIndexOf("0"));
}
//Arrays
{
String []array=new String[]{"a","b","c"};
List list=Arrays.asList(array);
System.out.println("\nArrays:");
for(int i=0;i<list.size();i++){
System.out.print(list.get(i)+";");
}
System.out.print("\nArrays\'s length is "+array.length);//打印数组的长度
}
//Collections
{
String []array=new String[]{"a","b","c"};
List list=Arrays.asList(array);
Collections.fill(list,"Fill");//用Fill填充全部元素
System.out.println("\nCollections:");
for(int i=0;i<list.size();i++){
System.out.print(list.get(i)+";");
}
array=new String[]{"1","2","3"};
List list2=Arrays.asList(array);
Collections.copy(list,list2);//拷贝list2的数据进list
System.out.println("\n"+list);
Collections.swap(list,2,1);//调换索引为1和2的元素的位置
System.out.println(list);
}
//EventObject
{
String s="hello";
String s2=s;
EventObject eventobject=new EventObject(s);//一个准容器类型，确切的归类它不是容器
System.out.println("EventObject:");
System.out.println(eventobject.getSource());
System.out.println(eventobject.equals(s2));
}
//HashMap
{
HashMap hashmap=new HashMap();//一个速度最快的容器
hashmap.put("0","c");
hashmap.put("1","a");
hashmap.put("2","b");
hashmap.put("3","a");
System.out.println("HashMap:");
System.out.println(hashmap);//该容器有其内部的排序方式
Set set=hashmap.keySet();//获取全部键
Iterator iterator=set.iterator();
while(iterator.hasNext()){
System.out.print(hashmap.get(iterator.next())+";");
}
}
//HashSet
{
HashSet hashset=new HashSet();//一个绝对不能重复的类型
hashset.add("c");
hashset.add("b");
hashset.add("a");
hashset.add("a");
hashset.add("b");
System.out.println("\nHashSet:");
System.out.println(hashset);
Iterator iterator=hashset.iterator();//取出元素
while(iterator.hasNext()){
System.out.print(iterator.next()+";");
}
}
//Hashtable
{
Hashtable hashtable=new Hashtable();//一个完全可以由其他容器替换的老容器类型
hashtable.put("0","c");
hashtable.put("1","a");
hashtable.put("3","c");
hashtable.put("2","b");
System.out.println("\nHashtable:");
Enumeration enumeration=hashtable.elements();//获取元素，Enumeration已经不是主流，Iterator是它的下一代替代品
while(enumeration.hasMoreElements()){
System.out.print(enumeration.nextElement()+";");
}
}
//IdentityHashMap
{
IdentityHashMap identityhashmap=new IdentityHashMap();
identityhashmap.put("0","c");
identityhashmap.put("1","a");
identityhashmap.put("3","b");
identityhashmap.put("2","a");
System.out.println("\nIdentityHashMap:");
System.out.println(identityhashmap);
System.out.println(identityhashmap.containsKey("3"));//是否包含这个键
System.out.println(identityhashmap.containsValue("a"));//是否包含值
Set set=identityhashmap.entrySet();//传为Set类型
System.out.println(set);
set=identityhashmap.keySet();//全部键
System.out.println(set);
}
//LinkedHashMap
{
LinkedHashMap linkedhashmap=new LinkedHashMap();
linkedhashmap.put("0","b");
linkedhashmap.put("2","a");
linkedhashmap.put("1","c");
linkedhashmap.put("3","b");
System.out.println("LinkedHashMap:");
System.out.println(linkedhashmap);
System.out.println(linkedhashmap.containsKey("2"));//是否包含这个键
System.out.println(linkedhashmap.containsValue("c"));//是否包含值
Set set=linkedhashmap.keySet();
Iterator iterator=set.iterator();
while(iterator.hasNext()){
System.out.print(linkedhashmap.get(iterator.next())+";");
}
}
//LinkedHashSet
{
LinkedHashSet linkedhashset=new LinkedHashSet();//它包含了几种Set的属性但却没有自己的特色
linkedhashset.add("c");
linkedhashset.add("a");
linkedhashset.add("a");
linkedhashset.add("b");
System.out.println("\nLinkedHashSet:");
System.out.println(linkedhashset);
System.out.println(linkedhashset.contains("a"));//是否包含对象
Iterator iterator=linkedhashset.iterator();
while(iterator.hasNext()){
System.out.print(iterator.next()+";");
}
}
//LinkedList
{
LinkedList linkedlist=new LinkedList();//自由使用是它的特色
linkedlist.add("a");
linkedlist.add(1,"c");
linkedlist.addLast("b");
linkedlist.addFirst("d");
System.out.println("\nLinkedList:");
System.out.println(linkedlist);
//linkedlist.clear();//该方法清空容器
//linkedlist.remove(0);//删除索引为0的元素
//linkedlist.remove("d");//删除值为d的元素
//linkedlist.removeFirst();//删除第一个元素
//linkedlist.removeLast();//删除最后一个元素
for(int i=0;i<linkedlist.size();i++){
System.out.print(linkedlist.get(i)+";");
}
}
//Stack
{
Stack stack=new Stack();//堆栈
stack.add("b");
stack.add(0,"c");
stack.push("d");
stack.add("e");
stack.push("a");
Enumeration enumeration=stack.elements();
System.out.println("\nStack:");
while(enumeration.hasMoreElements()){
System.out.print(enumeration.nextElement()+";");
}
//后进先出
System.out.println("\n"+stack.peek());
System.out.println(stack.pop());
System.out.println(stack.contains("d")+";"+stack.contains("a"));//是否包含该元素,有趣的事情发生了
System.out.println(stack.search("c"));//非常有用的属性，检索，但是由后向前的排列
}
//TreeMap
{
TreeMap treemap=new TreeMap();
treemap.put("0","d");
treemap.put("2","a");
treemap.put("1","b");
treemap.put("3","c");
System.out.println("\nTreeMap:");//可以对键排序
System.out.println(treemap);
System.out.println(treemap.firstKey());//返回第一个键
Set set=treemap.keySet();
Iterator iterator=set.iterator();
while(iterator.hasNext()){
System.out.print(treemap.get(iterator.next())+";");
}
}
//TreeSet
{
TreeSet treeset=new TreeSet();//自动排序内容
treeset.add("b");
treeset.add("a");
treeset.add("c");
treeset.add("d");
System.out.println("\nTreeSet:");
System.out.println(treeset);
System.out.println(treeset.first());//返回第一个元素
Iterator iterator=treeset.iterator();
while(iterator.hasNext()){
System.out.print(iterator.next()+";");
}
}
//Vector
{
Vector vector=new Vector();
vector.add(0,"b");
vector.add("a");
vector.addElement("d");
vector.add("c");
System.out.println("\nVector:");
System.out.println(vector);
vector.set(2,"h");//替换掉指定索引的元素
System.out.println(vector);
Object []str=vector.toArray();
for(int i=0;i<str.length;i++){
System.out.print(str[i]+";");
}
vector.setSize(2);//重新设置大小为2
System.out.println("\n"+vector);
}
//WeakHashMap
{
WeakHashMap weakhashmap=new WeakHashMap();
weakhashmap.put("1","b");
weakhashmap.put("2","c");
weakhashmap.put("0","d");
weakhashmap.put("3","a");
System.out.println("\nWeakHashMap:");
System.out.println(weakhashmap);
System.out.println(weakhashmap.containsKey("3"));//是否包含键
System.out.println(weakhashmap.containsValue("d"));//是否包含值
Set set=weakhashmap.entrySet();
Iterator iterator=set.iterator();
while(iterator.hasNext()){
System.out.print(iterator.next()+";");
}
//weakhashmap.remove("2");//删除该键对应的值
//weakhashmap.get("1");//获取指定键的值
}
}
1.    在业务层使用JDBC直接操作数据库－最简单，最直接的操作

1）数据库url,username,password写死在代码中
     Class.forName("oracle.jdbc.driver.OracleDriver").newInstance();
     String url="jdbc:oracle:thin:@localhost:1521:orcl";
     String user="scott";
     String password="tiger";
     Connection conn= DriverManager.getConnection(url,user,password);  
     Statement stmt=conn.createStatement(
ResultSet.TYPE_SCROLL_SENSITIVE,ResultSet.CONCUR_UPDATABLE);
     String sql="select * from test";
     ResultSet rs=stmt.executeQuery(sql);

2）采用Facade和Command模式，使用DBUtil类封装JDBC操作；
       数据库url,username,password可以放在配置文件中（如xml,properties,ini等）。
       这种方法在小程序中应用较多。

2.DAO(Data Accessor Object)模式－松耦合的开始
DAO = data + accessor + domain object

例如User类－domain object (javabean)
UserDAO类－accessor ，提供的方法getUser(int id)，save(User user)内包含了JDBC操作
在业务逻辑中使用这两个类来完成数据操作。

使用Factory模式可以方便不同数据库连接之间的移植。

3.数据库资源管理模式
3.1 数据库连接池技术
资源重用，避免频繁创建，释放连接引起大大量性能开销；
更快的系统响应速度；

通过实现JDBC的部分资源对象接口( Connection, Statement, ResultSet )，可以使用Decorator设计模式分别产生三种逻辑资源对象: PooledConnection, PooledStatement和 PooledResultSet。


一个最简单地数据库连接池实现：
public class ConnectionPool {

        private static Vector pools;
        private final int POOL_MAXSIZE = 25;
        /**
         * 获取数据库连接
         * 如果当前池中有可用连接，则将池中最后一个返回；若没有，则创建一个新的返回
         */
        public synchronized Connection getConnection() {
               Connection conn = null;
               if (pools == null) {
                      pools = new Vector();
               }

               if (pools.isEmpty()) {
                      conn = createConnection();
               } else {
                      int last_idx = pools.size() - 1;
                      conn = (Connection) pools.get(last_idx);
                      pools.remove(last_idx);
               }

               return conn;
        }

        /**
         * 将使用完毕的数据库连接放回池中
         * 若池中连接已经超过阈值，则关闭该连接；否则放回池中下次再使用
         */
        public synchronized void releaseConnection(Connection conn) {
               if (pools.size() >= POOL_MAXSIZE)
                      try {
                             conn.close();
                      } catch (SQLException e) {
                             // TODO自动生成 catch 块
                             e.printStackTrace();
                      } else
                      pools.add(conn);
        }

        public static Connection createConnection() {
               Connection conn = null;
               try {
                      Class.forName("oracle.jdbc.driver.OracleDriver").newInstance();
                      String url = "jdbc:oracle:thin:@localhost:1521:orcl";
                      String user = "scott";
                      String password = "tiger";
                      conn = DriverManager.getConnection(url, user, password);
               } catch (InstantiationException e) {
                      // TODO自动生成 catch 块
                      e.printStackTrace();
               } catch (IllegalAccessException e) {
                      // TODO自动生成 catch 块
                      e.printStackTrace();
               } catch (ClassNotFoundException e) {
                      // TODO自动生成 catch 块
                      e.printStackTrace();
               } catch (SQLException e) {
                      // TODO自动生成 catch 块
                      e.printStackTrace();
               }
               return conn;
        }
}

注意：利用getConnection()方法得到的Connection，程序员很习惯地调用conn.close()方法关闭了数据库连接，那么上述的数据库连接机制便形同虚设。在调用conn.close()方法方法时如何调用releaseConnection()方法？这是关键。这里，我们使用Proxy模式和java反射机制。

public synchronized Connection getConnection() {
               Connection conn = null;
               if (pools == null) {
                      pools = new Vector();
               }

               if (pools.isEmpty()) {
                      conn = createConnection();
               } else {
                      int last_idx = pools.size() - 1;
                      conn = (Connection) pools.get(last_idx);
                      pools.remove(last_idx);
               }
        
         ConnectionHandler handler=new ConnectionHandler(this);
               return handler.bind(con);
        }

public class ConnectionHandler implements InvocationHandler {
      private Connection conn;
      private ConnectionPool pool;
     
      public ConnectionHandler(ConnectionPool pool){
             this.pool=pool;
      }
     
      /**
       * 将动态代理绑定到指定Connection
       * @param conn
       * @return
       */
      public Connection bind(Connection conn){
             this.conn=conn;
Connection proxyConn=(Connection)Proxy.newProxyInstance(
conn.getClass().getClassLoader(), conn.getClass().getInterfaces(),this);
           return proxyConn;
      }
     
        /* （非 Javadoc）
         * @see java.lang.reflect.InvocationHandler#invoke(java.lang.Object, java.lang.reflect.Method, java.lang.Object[])
         */
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
               // TODO自动生成方法存根
               Object obj=null;
               if("close".equals(method.getName())){
                      this.pool.releaseConnection(this.conn);
               }
               else{
                      obj=method.invoke(this.conn, args);
               }
              
               return obj;
        }
}

       在实际项目中，并不需要你来从头开始来设计数据库连接池机制，现在成熟的开源项目，如C3P0,dbcp,Proxool等提供了良好的实现。一般推荐使用Apache dbcp，基本使用实例：
DataSource ds = null;
    try{
      Context initCtx = new InitialContext();
      Context envCtx = (Context) initCtx.lookup("java:comp/env");
      ds = (DataSource)envCtx.lookup("jdbc/myoracle");
         if(ds!=null){
                 out.println("Connection is OK!");
                 Connection cn=ds.getConnection();
                 if(cn!=null){
                         out.println("cn is Ok!");
                 Statement stmt = cn.createStatement();
                  ResultSet rst = stmt.executeQuery("select * from BOOK");
                 out.println("<p>rst is Ok!" + rst.next());
                 while(rst.next()){
                         out.println("<P>BOOK_CODE:" + rst.getString(1));
                   }
                         cn.close();
                 }else{
                         out.println("rst Fail!");
                 }
         }
         else
                 out.println("Fail!");
            }catch(Exception ne){ out.println(ne);
          }


3.2 Statement Pool
普通预编译代码：
String strSQL=”select name from items where id=?”;
PreparedStatement ps=conn.prepareStatement(strSQL);
ps.setString(1, “2”);
ResultSet rs=ps.executeQuery();

但是PreparedStatement 是与特定的Connection关联的，一旦Connection关闭，则相关的PreparedStatement 也会关闭。
为了创建PreparedStatement 缓冲池，可以在invoke方法中通过sql语句判断池中还有没有可用实例。

4. 持久层设计与O/R mapping 技术
1） Hernate：适合对新产品的开发，进行封闭化的设计
Hibernate 2003年被Jboss接管，通过把java pojo对象映射到数据库的table中，采用了xml/javareflection技术等。3.0提供了对存储过程和手写sql的支持，本身提供了hql语言。
开发所需要的文件：
hibernate配置文件： hibernate.cfg.xml 或 hibernate.properties
hibernate 映射文件： a.hbm.xml
pojo类源文件： a.java　　

导出表与表之间的关系：
a. 从java对象到hbm文件：xdoclet
b. 从hbm文件到java对象：hibernate extension
c. 从数据库到hbm文件：middlegen
d. 从hbm文件到数据库：SchemaExport

2）Iatis ：适合对遗留系统的改造和对既有数据库的复用，有很强的灵活性 3） Apache OJB：优势在于对标准的全面支持 4）EJB：适合集群服务器，其性能也不象某些人所诟病的那么差劲 5） JDO (java data object)
设置一个Properties对象，从而获取一个JDO的PersistenceManagerFactory（相当于JDBC连接池中的DataSource），进而获得一个PersistenceManager对象（相当于JDBC中的Connection对象），之后，你可以用这个PersistenceManager对象来增加、更新、删除、查询对象。
JDOQL是JDO的查询语言；它有点象SQL，但却是依照Java的语法的。

5. 基于开源框架的Struts+Spring+Hibernate实现方案
示例：这是一个3层架构的web 程序，通过一个Action 来调用业务代理，再通过它来回调 DAO类。下面的流程图表示了MyUsers是如何工作的。数字表明了流程的先后顺序，从web层(UserAction)到中间层(UserManager)，再到数据层(UserDAO)，然后返回。
Spring是AOP, UserManager和UserDAO都是接口.
1)        web层(UserAction) ：调用中间层的接口方法，将UserManager作为属性注入。
              采用流行的Struts框架，虽然有很多人不屑一顾，但是这项技术在业界用的比较普遍，能满足基本的功能，可以减少培训学习成本。
2)        中间层(UserManager)：将UserDAO作为属性注入，其实现主要是调用数据层接口的一些方法；它处于事务控制中。
             采用Spring框架实现，IOC与AOP是它的代名词，功能齐全，非常棒的一个架构。
3)        数据层(UserDAO)：实现类继承HibernateDaoSupport类，在该类中可以调用getHibernateTemplate()的一些方法执行具体的数据操作。
             采用Hibernate做O/R mapping，从种种迹象可以看出，Hibernate就是EJB3.0的beta版。

　　今天工作的任务要写一些跟开源协议相关的约定说明，所以在网上搜索了一些资料以供参考，下面列出了几个比较常见的开源协议，如果想要了解其他的协议和详细了解这些协议，我个人推荐这个网址：http://www.opensource.org/licenses/

　　Mozilla Public License

　　MPL License，允许免费重发布、免费修改，但要求修改后的代码版权归软件的发起者。这种授权维护了商业软件的利益，，它要求基于这种软件得修改无偿贡献版权给该软件。这样，围绕该软件得所有代码得版权都集中在发起开发人得手中。但MPL是允许修改，无偿使用得。MPL软件对链接没有要求。

　　BSD开源协议

　　BSD开源协议是一个给于使用者很大自由的协议。可以自由的使用，修改源代码，也可以将修改后的代码作为开源或者专有软件再发布。 当你发布使用了BSD协议的代码，或则以BSD协议代码为基础做二次开发自己的产品时，需要满足三个条件：

　　1. 如果再发布的产品中包含源代码，则在源代码中必须带有原来代码中的BSD协议。

　　2. 如果再发布的只是二进制类库/软件，则需要在类库/软件的文档和版权声明中包含原来代码中的BSD协议。

　　3. 不可以用开源代码的作者/机构名字和原来产品的名字做市场推广。

　　BSD代码鼓励代码共享，但需要尊重代码作者的著作权。BSD由于允许使用者修改和重新发布代码，也允许使用或在BSD代码上开发商业软件发布和销售，因此是对商业集成很友好的协议。而很多的公司企业在选用开源产品的时候都首选BSD协议，因为可以完全控制这些第三方的代码，在必要的时候可以修改或者二次开发。

　　Apache Licence 2.0

　　Apache Licence是著名的非盈利开源组织Apache采用的协议。该协议和BSD类似，同样鼓励代码共享和尊重原作者的著作权，同样允许代码修改，再发布(作为开源或商业软件)。需要满足的条件：

　　1. 需要给代码的用户一份Apache Licence

　　2. 如果你修改了代码，需要再被修改的文件中说明。

　　3. 在延伸的代码中(修改和有源代码衍生的代码中)需要带有原来代码中的协议，商标，专利声明和其他原来作者规定需要包含的说明。

　　4. 如果再发布的产品中包含一个Notice文件，则在Notice文件中需要带有Apache Licence。你可以在Notice中增加自己的许可，但不可以表现为对Apache Licence构成更改。

　　Apache Licence也是对商业应用友好的许可。使用者也可以在需要的时候修改代码来满足需要并作为开源或商业产品发布/销售。

　　GPL

　　GPL许可证是自由软件的应用最广泛的软件许可证，人们可以修改程式的一个或几个副本或程式的任何部分，以此形成基於这些程式的衍生作品。必须在修改过的档案中附有明显的说明：您修改了此一档案及任何修改的日期。 您必须让您发布或出版的作品，包括本程式的全部或一部分，或内含本程式的全部或部分所衍生的作品，允许第三方在此许可证条款下使用，并且不得因为此项授权行为而收费。

　　LGPL

　　Linux就是采用了GPL。GPL协议和BSD, Apache Licence等鼓励代码重用的许可很不一样。GPL的出发点是代码的开源/免费使用和引用/修改/衍生代码的开源/免费使用，但不允许修改后和衍生的代码做为闭源的商业软件发布和销售。这也就是为什么我们能用免费的各种linux，包括商业公司的linux和linux上各种各样的由个人，组织，以及商业软件公司开发的免费软件了。

　　GPL协议的主要内容是只要在一个软件中使用(“使用”指类库引用，修改后的代码或者衍生代码)GPL协议的产品，则该软件产品必须也采用GPL协议，既必须也是开源和免费。这就是所谓的”传染性”。GPL协议的产品作为一个单独的产品使用没有任何问题，还可以享受免费的优势。

　　由于GPL严格要求使用了GPL类库的软件产品必须使用GPL协议，对于使用GPL协议的开源代码，商业软件或者对代码有保密要求的部门就不适合集成/采用作为类库和二次开发的基础。

　　其它细节如再发布的时候需要伴随GPL协议等和BSD/Apache等类似

　　Public Domain

　　公共域授权。将软件授权为公共域，这些软件包没有授权协议，任何人都可以随意使用它。

　　Artistic许可

　　使作者保持对进一步开发的控制。

　　使用Java语言编写应用程序最大的优点在于“一次编译，处处运行”，然而这并不是说所有的Java程序都具有跨平台的特性，事实上，相当一部分的Java程序是不能在别的操作系统上正确运行的，那么如何才能编写一个真正的跨平台的Java程序呢？下面是在编写跨平台的Java程序是需要注意的一些事情：

　　1．编写Java跨平台应用程序时，你可以选择JDK1.0，1.1，1.2或支持它们的GUI开发工具如：Jbuilder,Visual Age for Java等等，但是必须注意你的Java程序只能使用Java核心API包，如果要使用第三方的类库包，则该类库包也要由Java核心包开发完成，否则在发布你的程序的时候还得将支持该Java类库包的JVM发布出去。也就是说，你的程序需要是100%纯Java的。举一个例子，Visual J++就不是纯Java的，由Visual J++编写的程序也就不具有平台无关性。

　　2．无论你使用的是JDK或其他开发工具，在编译时都要打开所有的警告选项，这样编译器可以尽可能多的发现平台相关的语句，并给出警告。虽然不能保证没有编译时警告错误的程序一定是跨平台的，但含有警告错误的程序却很有可能是非平台无关的。

　　3．在程序中使用任何一个方法的时候，要详细察看文档，确保你使用的方法不是在文档中已经申明为过时的方法（Deprecated method）,也不是文档中未标明的隐含方法（Undocumented method）。

　　4．退出Java程序时尽量不要使用java.lang.System的exit方法。Exit方法可以终止JVM，从而终止程序，但如果同时运行了另一个Java程序，使用exit方法就会让该程序也关闭，这显然不是我们希望看到的情况。事实上要退出Java程序，可以使用destory()退出一个独立运行的过程。对于多线程程序，必须要关闭各个非守护线程。只有在程序非正常退出时，才使用exit方法退出程序。

　　5．避免使用本地方法和本地代码，尽可能自己编写具有相应功能的Java类，改写该方法。如果一定要使用该本地方法，可以编写一个服务器程序调用该方法，然后将现在要编写的程序作为该服务器程序的客户程序，或者考虑CORBA（公共对象请求代理）程序结构。

　　6．Java中有一个类似于Delphi中的winexec的方法，java.lang.runtime类的exec方法，作为该方法本身是具有平台无关性的，但是给方法所调用的命令及命令参数却是与平台相关的，因此，在编写程序时要避免使用，如果一定要调用其他的程序的话，必须要让用户自己来设置该命令及其参数。比如说，在windows中可以调用notepad.exe程序，在linux中就要调用vi程序了。

　　7．程序设计中的所有的信息都要使用ASCII码字符集，因为并不是所有的操作系统都支持Unicode字符集，这对于跨平台的Java中文软件程序不能不说是一大噩耗。

　　8．在程序中不要硬性编码与平台相关的任何常量，比如行分隔符，文件分隔符，路径分隔符等等，这些常量在不同的平台上是不同的，比如文件分隔符，在UNIX和MAC中是“/”，在windows中是“”，如果要使用这些常量，需要使用jdava.util.Properties类的getProperty方法，如java.util.Properties.getProperty(“file.separator”)可以获得文件分隔符，getProperty (“line.separator”)返回行分隔符，getProperty(“path.separator”)返回路径分隔符。

　　9．在编写跨平台的网络程序时，不要使用java.net.InetAddress类的getHostName方法得到主机名，因为不同的平台的主机名格式是不同的，最好使用getAddress得到格式相同的IP地址，另外，程序中所有的主机名都要换成IP地址，比如www.263.net就要换成相应的IP地址。

　　10．涉及文件操作的程序需要注意：不要在程序中硬性编码文件路径，理由和8中一样，只是这一点特别重要，因此单独提出。而且，不同平台对于文件名使用的字符及最大文件名长度的要求不同，编写你的程序的时候要使用一般的ASCII码字符作为文件的名字，而且不能与平台中已存在的程序同名，否则会造成冲突。

　　11．如果您写的程序是GUI程序，在使用AWT组件时不能硬性设置组件的大小和位置而应该使用Java的布局管理器（layout manager）来设置和管理可视组件的大小和位置，否则有可能造成布局混乱。

　　12．由于不同的操作系统，不同的机器，系统支持的颜色和屏幕的大小和分辨率都不同，如何获得这些属性呢？使用java.awt.Systemcolor类可以获得需要的颜色，如该类的inactiveCaption就是窗口边框中活动标题的背景颜色，menu则是菜单的背景颜色。使用java.awt.Toolkit的getScreenResolution可以以“象素每英寸”为单位显示屏幕的分辨率。该类的getScreenSize可以得到屏幕大小（英寸），loadSystemColors可以列出所有的系统颜色。

　　这些注意事项有些是来自参考文献，有些是自己长期编写Java程序的经验所得，相信对你的程序设计会有所帮助。