Hibernate之HibernateTemplate的封装以及匿名内部类的使用

（一）HibernateTemplate的封装采用的是模板方法（Template  Method）的设计模式。

通过学习Hibernate，我们可以知道在事务开始之前和事务提交之后的代码是很固定的，我们可以对其进行封装，只有事务中间的部分有我们自己填写，来简化重复的代码。

实例：

public class MyHibernateTemplate {
public void executeWithNativeSession(MyHibernateCallback callback) { //通过传入接口的参数实现对方法的调用，填写中间代码
Session s = null;
try {
s = getSession();
s.beginTransaction();  //事务开始之前的代码

callback.doInHibernate(s);   //事务之间的代码，即需要我们自己填写的代码，这样一封装，就简化很多了

                         //封装之后需要提供一个接口，来填写事务中间这段代码。直接调用

s.getTransaction().commit();  //事务提交之后的代码
} catch (Exception e) {
s.getTransaction().rollback();
} finally {
//...
}
}

        private Session getSession() {
// TODO Auto-generated method stub
return null;
}
public void save(final Object o) {
new MyHibernateTemplate().executeWithNativeSession(new MyHibernateCallback() {  //采用匿名内部类的方法
public void doInHibernate(Session s) {
s.save(o);
}
});
}
}

封装之后提供的接口

public interface MyHibernateCallback {
public void doInHibernate(Session s);  //传入session 进行事务的处理（即中间代码）
}

通过创建一个HibernateCallback的实例，直接调用save（）方法。

（二）匿名内部类

匿名内部类就是没有名字的局部内部类，不使用关键字class, extends, implements, 没有构造方法。

只能创建匿名内部类的一个实例。

一个匿名内部类一定是在new的后面，用其隐含实现一个接口或实现一个类。

格式：

new  抽象类或者接口 （）{ //抽象类或者接口没有实现的方法的实现 }

实例：

定义一个接口

3 public interface Object {
4     public void show();
5 }

内部类的实现细节
 2         new Object(){
 3             void show(){
 4                 System.out.println("show run");                
 5             }
 6         }.show();//正确
 7         //2
 8         Object obj = new Object(){
 9             void show(){
10                 System.out.println("show run");
11             }
12         };
13         obj.show();//编译错误

 第一个可是编译通过，并运行。
 第二个编译失败，因为匿名内部类是一个子类对象，当用Object的obj引用指向时，就被提升为了Object类型，而编译时检查Object类中是否有show方法，

所以编译失败。

（三）内部类

作为外部类的一个成员存在，与外部类的属性、方法并列。

成员内部类也是定义在另一个类中，但是定义时不用static修饰。

成员内部类和静态内部类可以类比为非静态的成员变量和静态的成员变量。

　　成员内部类就像一个实例变量。

　　它可以访问它的外部类的所有成员变量和方法，不管是静态的还是非静态的都可以。

　　在外部类里面创建成员内部类的实例：

　　this.new B()；

　　在外部类之外创建内部类的实例：

　　(new Test1()).new B().go();

　　在内部类里访问外部类的成员：

　　Test1.this.member

　　

 1 package memberiner;
 2 
 3 public class Test1 {
 4     private String member="这是外部类变量";
 5     //成员内部类
 6     //不对外开放，高内聚
 7     class B{
 8         public B() {//当内部类的构造器为Protected、private修饰时外部类外不可以访问
 9             
10         }
11         public void go(){
12             System.out.println("这是内部类B的go方法"+Test1.this.member);//内部类访问外部类变量
13         }
14     }
15     
16     
17     //可供成员的外部类中其他方法调用
18     public  B show(){
19         
20         return this.new B();//外部类调用
21         
22     }
23     
24     public static void main(String[] args) {
25         
26         B b = new Test1().show();
27     }
28 
29 }
30 
31 
32 package memberiner;
33 
34 public class A {
35 
36     public static void main(String[] args) {
37             
38             new Test1().show();
39             
40             (new Test1()).new B().go();//外部类外访问内部类
41     }
42 
43 }