本文章主要讲了两个技巧,一是在Dao层中基本操作的复用，和Spring配置中的一些代码复用。

简明的说一下类的作用：

BaseDao（接口类）：

实体中共有的增删改查操作的接口

BaseHibernateDao（实现类）：继承HibernateDaoSupport，实现BaseDao接口

实现BaseDao类中的基本操作。

UserDao（接口类）：继承BaseDao类

实体中除了基本操作的额外操作，用于扩充功能。

UserHibernateDao（实现类）：继承BaseHibernateDao类，实现UserDao接口

实现UserDao类的操作。

从上面的分析可以看出来，UserDao类是包含有全部的底层操作的接口，而UserHibernateDao类是实现了UserDao

类的全部操作。实现了base类后，实际上是简化了实体通用的操作，只写一次就行了。。

在ssh2 结构中，可以利用spring 对UserService 类进行注入UserDao类即可。如Spring的配置文件： 

    <bean id="daoTemplate" abstract="true">
<property name="sessionFactory" ref="sessionFactory"></property>
</bean>
<bean id="userDao" class="dao.hibernate.UserHibernateDao" parent="daoTemplate"/>
<bean id="userService" class="service.imp.UserService">
<property name="userDao" ref="userDao"/>
<bean id="***Dao" class="dao.hibernate.***HibernateDao" parent="daoTemplate"/>
<bean id="***Service" class="service.imp.UserService">
<property name="***Dao" ref="***Dao"/>

从这个配置文件上又有个 daoTemplate 的bean ，这个bean 是一个抽象类，注入了sessionFactory，如果其他bean类继承它的话，就可以不用在为它注入sessionFactory了，，这个也是一个技巧，有点像Base类，功能都是实现代码的复用。。。

下面是上面一些类的演示代码：

BaseDao

import java.io.Serializable;
import java.util.List;
public interface BaseDao<T,ID extends Serializable> {
public void save(T entity);
public void delete(T entity);
public void deleteById(Class<T> entityClass,ID id);
public void update(T entity);
public T findById(Class<T> entityClass,ID id);
public List<T> findAll(Class<T> entityClass);
}

BaseHibernateDao

package dao.base;
import java.io.Serializable;
import java.util.List;
import org.springframework.orm.hibernate3.support.HibernateDaoSupport;
public class BaseHibernateDao<T,ID extends Serializable> extends HibernateDaoSupport implements BaseDao<T,ID> {
@Override
public void delete(T entity) {
this.getHibernateTemplate().delete(entity);
}
@Override
public void deleteById(Class<T> entityClass, ID id) {
delete(this.findById(entityClass, id));
}
@Override
public T findById(Class<T> entityClass, ID id) {
return (T)this.getHibernateTemplate().get(entityClass, id);
}
@Override
public List<T> findAll(Class<T> entityClass) {
String name=entityClass.getName();
return this.getHibernateTemplate().find("from"+name);
}
@Override
public void save(T entity) {
this.getHibernateTemplate().save(entity);
}
@Override
public void update(T entity) {
this.getHibernateTemplate().update(entity);
}
}

UserDao

package dao;
import dao.base.BaseDao;
import model.User;
public interface UserDao extends BaseDao<User,Integer>{
User findUserByNameAndPass(String name,String password);
}

 UserHibernateDao

package dao.hibernate;   
   
import java.util.List;   
   
import model.User;   
import dao.UserDao;   
import dao.base.BaseHibernateDao;   
   
public class UserHibernateDao extends BaseHibernateDao<User,Integer> implements UserDao {   
   
    @Override   
    public User findUserByNameAndPass(String name, String password) {   
        // TODO Auto-generated method stub   
        List<User> us=this.getHibernateTemplate().find("from User user where name=? and password=?",new Object[]{name,password});   
        if(us.size()==1)   
            return us.get(0);   
        else   
            return null;   
    }   
   
} 

{    
 3   
 4   
 5    // Fields        
 6   
 7     private long id;    
 8     private String name;    
 9     private String email;    
10     private String addr;    
11     //定义Blob的pthto    
12     private Blob photo;   
13
14xml 代码
15<hibernate-mapping>   
16    <class name="org.tie.User" table="user" catalog="tie">   
17        <id name="id" type="long">   
18            <column name="id" />   
19            <generator class="identity" />   
20        </id>   
21        <property name="name" type="string">   
22            <column name="name" length="45" not-null="true" />   
23        </property>   
24        <property name="email" type="string">   
25            <column name="email" length="45" />   
26        </property>   
27        <property name="addr" type="string">   
28            <column name="addr" length="45" />   
29        </property>   
30        <!-- 映射blob类型 -->   
31        <property name="photo" type="blob">   
32            <column name="photo" />   
33        </property>   
34    </class>   
35</hibernate-mapping>   
36
37两个测试方法:
38
39java 代码
40public void testCreate(){    
41            
42        User user = new User();    
43        user.setName("linweiyang");    
44        user.setAddr("beijing");    
45        user.setEmail("linweiyang@163.com");    
46        Blob photo = null;    
47        
48        try {    
49            //将图片读进输入流    
50            FileInputStream fis = new FileInputStream("c:\\a.jpg");    
51            //转成Blob类型    
52            photo = Hibernate.createBlob(fis);    
53                
54        } catch (FileNotFoundException e) {    
55            e.printStackTrace();    
56        } catch (IOException e) {    
57            e.printStackTrace();    
58        }    
59                
60        user.setPhoto(photo);    
61            
62        Session session = factory.openSession();    
63        Transaction tr = session.beginTransaction();    
64        session.save(user);    
65        tr.commit();    
66        session.close();    
67   
68    }    
69        
70    public void testRerieve(){    
71            
72        Session session = factory.openSession();    
73        User user = (User)session.load(User.class, new Long(3));    
74        try {    
75            //从数据库中要读取出来    
76            InputStream is = user.getPhoto().getBinaryStream();    
77            //在把写到一个图片格式的文件里    
78            FileOutputStream fos = new FileOutputStream("c:\\linweihan.jpg");    
79                
80            byte[] buffer = new byte[1024];    
81            int len = 0;    
82            //从数据库中读取到指定的字节数组中    
83            while((len = is.read(buffer) )!= -1){    
84                //从指定的数组中读取，然后输出来，所以这里buffer好象是连接inputStream和outputStream的一个东西    
85                fos.write(buffer,0,len);    
86            }    
87        } catch (FileNotFoundException e) {    
88            e.printStackTrace();    
89        } catch (SQLException e) {    
90            e.printStackTrace();    
91        } catch (IOException  e){    
92            e.printStackTrace();    
93        }               
94        session.close();    
95    }   

这么理解输入输出流

读入流,自然要有读入的源头,

输出也要输出到某个地方,输出一般是先要输读入,

这里连接输入和输出的是一个在内存中的字节数组buffer.这样从数据库中读到这个数组里,输出流在从这个数组中输出到特定的文件格式里.

目前常见的web application的结构，包含web browser/application server/database。database占据主流的仍然是经典的E/R模型，这个模型是基于行集的，因此在VB/Delphi/Power Builder的实践中，data source/table set都是基于行集的，odbc/JDBC driver也都是基于行集的。view层的DbGrid也是基于行集的，和Entity模型对应得非常好，开发简易直观，相信这是C/S模式得到迅速推广的重点原因之一。“master-detail”,"lookup"都是C/S模式下极为常见和直观的关联模式。

但本质上，Object pascal/java都是面向对象的。在此，就出现了一次重大的不统一：OO vs E-R。出现的解决方式就是EJB和O/R mapping 工具。EJB的entity bean是早期的entity封装形式。但是和现在以hibernate为代表的先进工具（对POJO执行持久化）比较起来，在OO与ER的对应上显得笨重而难于使用。在这些工具中，代表OO与E-R融合的最本质的功能则是继承树与表结构的对应关系。hibernate2支持整棵继承树与一个表对应、继承树中每个类与一个表对应两种基本的对应关系，而hibernate 3引入的join标记则更可以将二者融合，实现每个类可选与基类在同一个表中持久或者在新表中保存部分持久数据，可以说hibernate 3把这个对应的任务完成得非常出色。"master-detail","lookup"则对应hbm.XML这样的映射文件中的"one-many","many-one"关联。

database与java的融合完成之后，下一步，不可避免的就是现有的web client与服务器端代码之间的融合。从表面上看，web client大多采用html/JavaScript完成，而服务器端采用java输出，二者是简单的命令/反馈的模型，这个模型从model 1发展到MVC的模型后，编写代码变得清晰，但是开发人员仍然发现，编写web app仍然不是一件简单的事情。Struts/webwork仍然只是非常底层的基础，对编写客户端业务对象没有什么帮助。比如说,在服务器端java程序建模时，大家已经习惯用pojo分析订单/客户/产品，但是在编写web client时，struts/webwork都只能帮助你完成页面提交/反馈的流程，却不能帮助你分析客户端业务：新建订单时，选择了客户之后，判断此客户是否有足够的预收款，这样一个简单用例在程序员心目中的反映仍然是每个字段的input tag,每个页面post上来的model,以及如何用action的处理再次渲染下一个页面。

最大的问题，就是作为表现层的web client端代码与服务器端代码蕴含的语义脱节。具体表现在：
 在采用struts/webwork这样的MVC结构的时候，通常不会考虑在客户端进行业务控制，比如由javascipt判断预收款是否足够。因此需要不断的多次页面刷新才能完成整个逻辑。

要解决此问题，通常可以采用把业务逻辑部分转移到客户端，以javascript + xmlhttp或javascript + web service,java Applet/application,甚至采用Office平台(嵌入代码到excel)完成整个业务逻辑。也有很多问题：

1，若要在客户端实现业务逻辑，可能客户端代码没有对应Pojo这样的基础object设施。javascript缺乏如interface这样的基础结构。excel方案在这点更加难于进行，因为整个开发涉及到的语言太多，造成开发难度加大，项目控制困难。
直接后果就是，难于在客户端代码中定义"master-detail","lookup"等关联。就算在项目规划中在javascript中定义pojo(plain old javascript object)及其关联，也难于利用hbm.xml这样的现成关联描述。

2，客户端基础设施难于进行界面元素绑定。在处理大量数据时，excel方案在此体现出杰出的优势，客户对内置程序的excel的接受程度非常高，但缺点是这种excel程序难于做到xmlhttp可以轻松做到的动态查询等特性。

3，客户端基础设施难于与服务器端进行交互。xmlhttp以及web service可选，但是在企业应用中其低下效率可能会带来服务器的压力隐患，降低性能和吞吐量。若excel方案，则同样面临着与服务器数据交互的难题。不管是xmlhttp方案还是application方案，都面临着抛弃struts/webwork重新实现request/response dispatch的要求。

4，客户端基础设施难于进行单元测试。有junit4js，port了junit 3.8.1，但没有成熟的stub/mock工具。excel方案在此几乎不可测试。

5, 客户端基础设施难于调试。javascript缺乏类似log4j这样的log工具(log4js http://www.petrusrex.com/Programmes/jslib.htm 这样的工具还远没有成熟)，也难于进行断点跟踪。excel方案倒是有完整的vba环境。

6, 客户端基础设施运行效率低。javascipt/vba都是解释语言，难于实现复杂逻辑，其性能决定只能用它们进行细粒度的界面控制。

7，由于浏览器的分裂，造成语言的不标准，应用程序难以跨平台使用。在IE平台上可以使用behavior和expression这种类AOP的操作，却无法在mozilla中实现。

jsf方案有望成为备选方案，但是按照myfaces目前的情况，要实现更多的表现层控件，才能完成更复杂灵活的控制。

下面一次软件开发方式的突破，向前看，可能出现设计方式的突破，MDA是方向；另一个方向就是向后对具体实现的突破，在类似webapp这样的具体技术（除了webapp,application同样面临类似问题）上，对于是否能够把model的定义直接带入到表现层，JSF和.net可能会有新一轮竞争。

查询结果从多张表中找出非常普遍，该例子教你实现查询结果bean的实现
1 插寻结果bean，A的属性a、b来源于已影射的bean M,N
class A
{
       String a,b;

       public A(String a,String b)
           {
             this.a=a;
             thia.b=b;
           }
}

2 编写查询方法

  Query q;
  List l = null;
  q = session.createQuery("select new A(M.a,N.b) from M as M,N as N where M.id=N.id");

3 资源载入A
<import class="package.A"/>