hibernate二级缓存的实现

2012-07-10

对于Hibernate这类ORM而言,缓存显的尤为重要,它是持久层性能提升的关键.简单来讲Hibernate就是对JDBC进行封装,以实现内部状态的管理,OR关系的映射等,但随之带来的就是数据访问效率的降低,和性能的下降,而缓存就是弥补这一缺点的重要方法.

缓存就是数据库数据在内存中的临时容器,包括数据库数据在内存中的临时拷贝,它位于数据库与数据库访问层中间.ORM在查询数据时首先会根据自身的缓存管理策略,在缓存中查找相关数据,如发现所需的数据,则直接将此数据作为结果加以利用,从而避免了数据库调用性能的开销.而相对内存操作而言,数据库调用是一个代价高昂的过程.

一般来讲ORM中的缓存分为以下几类:

    1.事务级缓存:即在当前事务范围内的数据缓存.就Hibernate来讲,事务级缓存是基于Session的生命周期实现的,每个Session内部会存在一个数据缓存,它随着Session的创建而存在,随着Session的销毁而灭亡,因此也称为Session Level Cache.

    2.应用级缓存:即在某个应用中或应用中某个独立数据库访问子集中的共享缓存,此缓存可由多个事务共享(数据库事务或应用事务),事务之间的缓存共享策略与应用的事务隔离机制密切相关.在Hibernate中,应用级缓存由SessionFactory实现,所有由一个SessionFactory创建的Session实例共享此缓存,因此也称为SessionFactory Level Cache.

    3.分布式缓存:即在多个应用实例,多个JVM间共享的缓存策略.分布式缓存由多个应用级缓存实例组成,通过某种远程机制(RMI,JMS)实现各个缓存实例间的数据同步,任何一个实例的数据修改,将导致整个集群间的数据状态同步.

Hibernate数据缓存:

    1.内部缓存(Session Level Cache也称一级缓存):

    举例说明:

java 代码
public class Test {

public void get(){     

      Session session = HibernateSessionFactory.getSession();    
      TUser t = (TUser)session.get("hibernate.TUser", 2);    
      System.out.println(t.getName());    
      session.close();    
      }

}

       进行测试:在控制台打印出一条SQL语句:Hibernate: select tuser0_.id as id0_0_, tuser0_.name as name0_0_, tuser0_.*** as ***0_0_ from test.t_user tuser0_ where tuser0_.id=? 说明进行了一次数据库的调用.

代码更改如下:

public class Test {

public void get(){    

      Session session = HibernateSessionFactory.getSession();    
      TUser t = (TUser)session.get("hibernate.TUser", 2);    
      System.out.println(t.getName());    
      TUser tt = (TUser)session.get("hibernate.TUser", 2);    
      System.out.println(tt.getName());    
      session.close();    

}

}

再进行测试:进行了两次查询,控制台仍然只打出一条SQL语句:Hibernate: select tuser0_.id as id0_0_, tuser0_.name as name0_0_, tuser0_.*** as ***0_0_ from test.t_user tuser0_ where tuser0_.id=?  说明还是只进行了一次数据库的调用.

再将代码更改如下:

public class Test {

public void get(){     

      Session session = HibernateSessionFactory.getSession();    
      TUser t = (TUser)session.get("hibernate.TUser", 2);    
      System.out.println(t.getName());    
      session.close();    
      Session session1 = HibernateSessionFactory.getSession();    
      TUser tt = (TUser)session1.get("hibernate.TUser", 2);    
      System.out.println(tt.getName());    
      session1.close();    

}

}

继续测试:进行两次查询控制台打印两条SQL语句:Hibernate: select tuser0_.id as id0_0_, tuser0_.name as name0_0_, tuser0_.*** as ***0_0_ from test.t_user tuser0_ where tuser0_.id=?

Hibernate: select tuser0_.id as id00, tuser0_.name as name00, tuser0_. as 00 from test.tuser tuser0 where tuser0_.id=?

结论:Hibernate进行查询时总是先在缓存中进行查询,如缓存中没有所需数据才进行数据库的查询.Hibernate的内部缓存是基于Session的生命周期的,也就是说存在于每个Session内部,它随着Session的创建而存在,随着Session的销毁而灭亡,内部缓存一般由Hibernate自动维护,不需要人为干预,当然我们也可以根据需要进行相应操作:Session.evict(Object)(将指定对象从内部缓存清除),Session.clear()(清空内部缓存).(如在两次查询间加入Session.clear()将会清空内部缓存,使得一个Sesion内部的两次相同的查询要对数据库进行两次操作).

2.二级缓存:(有时称为SessionFactory Level Cache)

Hibernate本身并未提供二级缓存的产品化实现(只提供了一个基于HashTable的简单缓存以供调试),这里我使用的是第三方缓存组件:EHcache.Hibernate的二级缓存实现需要进行以下配置(Hibernate3):

首先在hibernate.cfg.xml内添加:

org.hibernate.cache.EhCacheProvider
true

然后在映射文件中添加:

测试上面代码:控制台输出多了这样一句[ WARN] (CacheFactory.java:43) - read-only cache configured for mutable class: hibernate.TUser,二级缓存启用成功!!

java 代码
public class Test {

 public void executeQuery(){    

       List list = new ArrayList();    
       Session session = HibernateSessionFactory.getSession();    
       Query query = session.createQuery("from TUser t");    
       query.setCacheable(true);//激活查询缓存    
       list = query.list();    
       session.close();    

 }    
 public void get(){    

       Session session = HibernateSessionFactory.getSession();    
       TUser t = (TUser)session.get("hibernate.TUser", 2);    
       System.out.println(t.getName());    
       session.close();    

}

}

测试:控制台只输出一条SQL语句:Hibernate: select tuser0_.id as id0_, tuser0_.name as name0_, tuser0_.*** as ***0_ from test.t_user tuser0_(即Query query = session.createQuery("from TUser t")这句代码所对应的SQL).  executeQuery()方法与get()方法使用的是不同的Session!!可是executeQuery()方法与get()方法只对数据库进行了一次操作,这就是二级缓存在起作用了.   

结论:Hibernate二级缓存是SessionFactory级的缓存,它允许多个Session间共享,使用时需要使用第三方的缓存组件,新版Hibernate将EHcache作为默认的二级缓存实现.

缓存同步策略:缓存同步策略决定了数据对象在缓存中的存取规则,我们必须为每个实体类指定相应的缓存同步策略.Hibernate中提供了4种不同的缓存同步策略:(暂时只记个概念吧)

1.read-only:只读.对于不会发生改变的数据可使用（对数据只能查询，其他的增删改都会报错不关是1或2缓存中）.

2.nonstrict-read-write:如果程序对并发访问下的数据同步要求不严格,且数据更新频率较低,采用本缓存同步策略可获得较好性能.(不能在二级缓存进行增删改都会报错)

3.read-write:严格的读写缓存.基于时间戳判定机制,实现了"read committed"事务隔离等级.用于对数据同步要求的情况,但不支持分布式缓存,实际应用中使用最多的缓存同步策略.（都可以比较常用的）

4.transactional:事务型缓存,必须运行在JTA事务环境中.此缓存中,缓存的相关操作被添加到事务中(此缓存类似于一个内存数据库),如事务失败,则缓冲池的数据会一同回滚到事务的开始之前的状态.事务型缓存实现了"Repeatable read"事务隔离等级,有效保证了数据的合法性,适应于对关键数据的缓存,Hibernate内置缓存中,只有JBossCache支持事务型缓存.

Hibernate获取数据的方式有不同的几种，其与缓存结合使用的效果也不尽相同，而Hibernate中具体怎么使用缓存其实是我们很关心的一个问题，直接涉及到性能方面。
缓存在Hibernate中主要有三个方面：一级缓存、二级缓存和查询缓存；一级缓存在Hibernate中对应的即为session范围的缓存，也就是当session关闭时缓存即被清除，一级缓存在Hibernate中是不可配置的部分；二级缓存在Hibernate中对应的即为SessionFactory范围的缓存，通常来讲SessionFactory的生命周期和应用的生命周期相同，所以可以看成是进程缓存或集群缓存，二级缓存在Hibernate中是可以配置的，可以通过class-cache配置类粒度级别的缓存(class-cache在class中数据发生任何变化的情况下自动更新)，同时也可通过collection-cache配置集合粒度级别的缓存(collection-cache仅在 collection中增加了元素或者删除了元素的情况下才自动更新，也就是当collection中元素发生值的变化的情况下它是不会自动更新的)，缓存自然会带来并发的访问问题，这个时候相应的就要根据应用来设置缓存所采用的事务隔离级别，和数据库的事务隔离级别概念基本一样，没什么多介绍的， ^^；查询缓存在Hibernate同样是可配置的，默认是关闭的，可以通过设置cache.use querycache为true来打开查询缓存。根据缓存的通常实现策略，我们可以来理解Hibernate的这三种缓存，缓存的实现通过是通过key/value的Map方式来实现，在 Hibernate的一级、二级和查询缓存也同样如此，一级、二级缓存使用的key均为po的主键ID，value即为po实例对象，查询缓存使用的则为查询的条件、查询的参数、查询的页数，value有两种情况，如果采用的是select po.property这样的方式那么value为整个结果集，如采用的是from这样的方式那么value为获取的结果集中各po对象的主键ID，这样的作用很明显，节省内存，^^
简单介绍完Hibernate的缓存后，再结合Hibernate的获取数据方式来说明缓存的具体使用方式，在Hibernate中获取数据常用的方式主要有四种：Session.load、Session.get、Query.list、Query.iterator。
1、Session.load
在执行session.load时，Hibernate首先从当前session的一级缓存中获取id对应的值，在获取不到的情况下，将根据该对象是否配置了二级缓存来做相应的处理，如配置了二级缓存，则从二级缓存中获取id对应的值，如仍然获取不到则还需要根据是否配置了延迟加载来决定如何执行，如未配置延迟加载则从数据库中直接获取，在从数据库获取到数据的情况下，Hibernate会相应的填充一级缓存和二级缓存，如配置了延迟加载则直接返回一个代理类，只有在触发代理类的调用时才进行数据库查询的操作。
在这样的情况下我们就可以看到，在session一直打开的情况下，要注意在适当的时候对一级缓存进行刷新操作，通常是在该对象具有单向关联维护的时候，在Hibernate中可以使用象session.clear、session.evict的方式来强制刷新一级缓存。
二级缓存则在数据发生任何变化(新增、更新、删除)的情况下都会自动的被更新。
2、Session.get
在执行Session.get时，和Session.load不同的就是在当从缓存中获取不到时，直接从数据库中获取id对应的值。
3、Query.list
在执行Query.list时，Hibernate的做法是首先检查是否配置了查询缓存，如配置了则从查询缓存中查找key为查询语句+查询参数+分页条件的值，如获取不到则从数据库中进行获取，从数据库获取到后Hibernate将会相应的填充一级、二级和查询缓存，如获取到的为直接的结果集，则直接返回，如获取到的为一堆id的值，则再根据id获取相应的值(Session.load)，最后形成结果集返回，可以看到，在这样的情况下，list也是有可能造成N次的查询的。
查询缓存在数据发生任何变化的情况下都会被自动的清空。
4、Query.iterator
在执行Query.iterator时，和Query.list的不同的在于从数据库获取的处理上，Query.iterator向数据库发起的是 select id from这样的语句，也就是它是先获取符合查询条件的id，之后在进行iterator.next调用时才再次发起session.load的调用获取实际的数据。
可见，在拥有二级缓存并且查询参数多变的情况下，Query.iterator会比Query.list更为高效。

这四种获取数据的方式都各有适用的场合，要根据实际情况做相应的决定，^_^，最好的方式无疑就是打开show_sql选项看看执行的情况来做分析，系统结构上只用保证这种调整是容易实现的就好了，在cache这个方面的调整自然是非常的容易，只需要调整配置文件里的设置，而查询的方式则可对外部进行屏蔽，这样要根据实际情况调整也非常容易。

hibernate关系注解映射

2012-07-07

一对多(最好不要用单向关联，其实单向本身并无多大意义)：

一方：
@OneToMany(targetEntity=Order.class,cascade=CascadeType.ALL,fetch=FetchType.EAGER)
@JoinColumn(name=”fk_customer_id”)

如果一方加了fetch=FetchType.EAGER，查单一的多方对象时，会多产生一条sql
targetEntity也可以写成mappedBy=”customer”（这里写的是多多中对一方的引用属性），表示由对方去维护外键关系。
注：一般会将fetch=FetchType.LAZY

多方：
@ManyToOne
@JoinColumn(name=”fk_customer_id”)
注：一般需要会将fetch=FetchType.LAZY，默认情况下多方会主动加载一方数据的。

配置实例（客户–>客户订单）：
客户中的集合：
@OneToMany(targetEntity=Order.class,cascade=CascadeType.ALL)
@JoinColumn(name=”fk_customer_id”)
private Set orders = new HashSet();
客户订单中的客户：
//订单所属客户
@ManyToOne(fetch=FetchType.LAZY)
@JoinColumn(name=”fk_customer_id”)
private Customer customer;

二、多对一

比较简单，示例：注册用户—->城市
@ManyToOne(targetEntity=City.class, fetch=FetchType.LAZY)
@JoinColumn(name=”fk_city_id”)
private City city;

三、多对多

示例：游戏用户，用户组

//用户参加的组
@ManyToMany(fetch=FetchType.LAZY)
@Cascade(value={org.hibernate.annotations.CascadeType.SAVE_UPDATE})
@JoinTable(name="t_user_group",joinColumns={@JoinColumn(name="fk_user_id")}
            ,inverseJoinColumns={@JoinColumn(name="fk_group_id")}
        )
private Set<Group> groups = new HashSet<Group>();

而在用户组中：
//该小组中所包含的用户

    @ManyToMany(mappedBy="groups")
    @Cascade(value={org.hibernate.annotations.CascadeType.SAVE_UPDATE})
    @JoinTable(name="t_user_group",joinColumns={@JoinColumn(name="fk_group_id")}
                ,inverseJoinColumns={@JoinColumn(name="fk_user_id")}
)

三、一对一惟一外键关联

示例：husband—->wife
而husband中（外键在t_husband表中）：
@OneToOne(cascade=CascadeType.ALL)
@JoinColumn(name=”fk_wife_id”,unique=true)
private Wife wife;

wife对象中：
@OneToOne(mappedBy=”wife”,cascade=CascadeType.ALL)
private Husband husband;

注解方式与spring的整合：

com.lovo.edu.model
com.lovo.edu.test

关于序列类型主键的配置示例：
@Id
@GeneratedValue(strategy=GenerationType.SEQUENCE, generator=”student_id”)
@SequenceGenerator(name=”student_id”, allocationSize=1, initialValue=1,sequenceName=”seq_student_id”)
private Long sid;
其它的一些主键生成方式：
@Id
@GenericGenerator(name=”idGenerator”, strategy=”uuid”)
@GeneratedValue(generator=”idGenerator”) //使用uuid的生成策略
同理：使用assigned策略则在strategy中指定 =”assigned”

枚举映射示例：

@Entity
@Table(name="t_husband")
public class Husband {
    
    //状态
    public enum State {
        haveMoney, noMoney
    }
    
    //状态
    @Enumerated
    @Column(name="f_state")
    private State state = State.noMoney;

Spring原理

2012-07-05

一、 IoC(Inversion of control): 控制反转

概念：控制权由对象本身转向容器；由容器根据配置文件去创建实例并创建各个实例之间的依赖关系
核心：bean工厂；在Spring中，bean工厂创建的各个实例称作bean

内部最核心的就是IOC
动态注入，让一个对象的创建不用new了，可以自动的生产，这其实就是利用java里的反射
反射其实就是在运行时动态的去创建、调用对象，Spring就是在运行时，跟xml Spring的配置文件来动态的创建对象，和调用对象里的方法的。

二、AOP(Aspect-Oriented Programming): 面向方面编程

1、代理的两种方式：
静态代理：
 针对每个具体类分别编写代理类；
 针对一个接口编写一个代理类；
动态代理：
针对一个方面编写一个InvocationHandler，然后借用JDK反射包中的Proxy类为各种接口动态生成相应的代理类
2、 AOP的主要原理：动态代理

另一个核心就是AOP

这个就是面向切面编程，可以为某一类对象进行监督和控制（也就是在调用这类对象的具体方法的前后去调用你指定的模块）从而达到对一个模块扩充的功能。这些都是通过配置类达到的。
Spring目的：就是让对象与对象（模块与模块）之间的关系没有通过代码来关联，都是通过配置类说明
管理的（Spring根据这些配置内部通过反射去动态的组装对象）
要记住：Spring是一个容器，凡是在容器里的对象才会有Spring所提供的这些服务和功能。
Spring里用的最经典的一个设计模式就是：模板方法模式。 Spring里的配置是很多的，很难都记住，但是Spring里的精华也无非就是以上的两点，把以上两点跟理解了
也就基本上掌握了Spring.

三、spring原理

spring的最大作用ioc/di,将类与类的依赖关系写在配置文件中，程序在运行时根据配置文件动态加载依赖的类，降低的类与类之间的藕合度。它的原理是在applicationContext.xml加入bean标记,在bean标记中通过class属性说明具体类名、通过property标签说明,该类的属性名、通过constructor-args说明构造子的参数。其一切都是返射，当通过applicationContext.getBean(“id名称”)得到一个类实例时，就是以bean标签的类名、属性名、构造子的参数为准，通过反射实例对象,唤起对象的set方法设置属性值、通过构造子的newInstance实例化得到对象。正因为spring一切都是反射，反射比直接调用的处理速度慢，所以这也是spring 的一个问题。spring第二大作用就是aop，其机理来自于代理模式，代理模式有三个角色分别是通用接口、代理、真实对象代理、真实对象实现的是同一接口，将真实对象作为代理的一个属性，向客户端公开的是代理，当客户端调用代理的方法时，代理找到真实对象，调用真实对象方法，在调用之前之后提供相关的服务，如事务、安全、日志。其名词分别是代理、真实对象、装备、关切点、连接点。

四、动态代理:

不用写代理类，虚拟机根据真实对象实现的接口产生一个类，通过类实例化一个动态代理，在实例化动态代理时将真实对象及装备注入到动态代理中，向客户端公开的是动态代理，当客户端调用动态代理方法时，动态代理根据类的返射得到真实对象的Method,调用装备的invoke方法，将动态代理、Method、方法参数传与装备的invoke方法，invoke方法在唤起method方法前或后做一些处理。

1、产生动态代理的类: 

        java.lang.refect.Proxy 

2、装备必须实现InvocationHandler接口实现invoke方法

java代理有jdk动态代理、cglib代理，这里只说下jdk动态代理，jdk动态代理主要使用的是java反射机制（既java.lang.reflect包）
原理是（歌手、经纪人做例子）：
建立一个公共的接口，比如：歌手public interface Singer；
用具体的类实现接口，比如：周杰伦，他是歌手所以实现Singer这个类，class MySinger implements Singer
建立代理类，这里也就是经纪人，他需要实现InvocationHandler类，并重写invoke方法
这样当有什么事情，要找周杰伦（具体类）的时候，就必须先到经纪人（代理类）那里处理，代理人在决定要不要与你见面（该方法要不要执行）
1、歌手接口
复制代码代码如下:

public interface Singer { 

public abstract void sing(); 

public abstract String s(); 
} 

2、具体的歌手 
复制代码代码如下:

public class MySinger implements Singer { 
public void sing() { 
// TODO Auto-generated method stub 
System.err.println("唱歌。。。。"); 
} 
} 

3、代理类（经纪人） 
复制代码代码如下:

public class agent implements InvocationHandler{ 
public Object target; 

//绑定 
public Object bind(Object target){ 
this.target=target; 
//必须放回Proxy 
return Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(), this); 
} 

//重新 
public Object invoke(Object proxy, Method method, Object[] args) 
throws Throwable { 
Object o =null; 
System.out.println("开始事务"); 
System.out.println("判断权限"); 

o = method.invoke(target, args);//执行方法 

System.out.println("结束事务"); 
return o; 
} 
}

4、测试（为什么要间接口能，下面你会发现代理返回的是他们的接口类，这要一个代理类，就可以代理多个类，只要该类是同个一个接口的是实现）
复制代码代码如下:

public class Test { 
public static void main(String[] args) { 
// 
agent a =new agent(); 
Singer s= (Singer) a.bind(new MySinger()); 
s.sing(); 
} 
}

五、反射：

什么是类的返射?

通过类说明可以得到类的父类、实现的接口、内部类、构造函数、方法、属性并可以根据构造器实例化一个对象，唤起一个方法，取属性值，改属性值。

如何得到一个类说明?

Class cls=类.class;

Class cls=对象.getClass();

Class.forName(“类路径”);

如何得到一个方法并唤起它?

Class cls=类.class; 

 Constructor cons=cls.getConstructor(new Class[]{String.class}); 

 Object obj=cons.newInstance(new Object[]{"aaa"}); 

  Method method=cls.getMethod("方法名",new Class[]{String.class,Integer.class}); 

                      method.invoke(obj,new Object[]{"aa",new Integer(1)});

六、spring的三种注入方式

setter 

interface 

constructor

七、spring的核心接口及核类配置文件

FactoryBean:工厂bean主要实现ioc/di 



        ApplicationContext ac=new FileXmlApplicationContext("applicationContext.xml"); 

        Object obj=ac.getBean("id值");

struts2的执行流程工作原理

2012-07-02

Struts 2框架本身大致可以分为3个部分：核心控制器FilterDispatcher、业务控制器Action和用户实现的企业业务逻辑组件。

Struts 2框架本身大致可以分为3个部分：核心控制器FilterDispatcher、业务控制器Action和用户实现的企业业务逻辑组件。核心控制器FilterDispatcher是Struts 2框架的基础，包含了框架内部的控制流程和处理机制。业务控制器Action和业务逻辑组件是需要用户来自己实现的。用户在开发Action和业务逻辑组件的同时，还需要编写相关的配置文件，供核心控制器FilterDispatcher来使用。 Struts 2的工作流程相对于Struts 1要简单，与WebWork框架基本相同，所以说Struts 2是WebWork的升级版本。基本简要流程如下：

More...

PermGenSpace溢出解决方

2012-06-23

PermGen space溢出解决方法
tomcat在运行几天后，会出现PermGen space溢出错误而无法继续处理请求，解决方法是调整PermGen区域大小：
JAVA_OPTS=”-server -XX:PermSize=64M -XX:MaxPermSize=128m”
还有一种说法是使用Jrockit代替sun实现的jdk，但我没有试验。
下面来看看对PermGen space的解释：
PermGen space的全称是Permanent Generation space，是指内存的永久保存区域，这个内存区域用于：
（1）这一部分用于存放Class和Meta的信息，Class在被 Load的时候被放入PermGen space区域，它和和存放Instance的Heap区域不同。
（2） GC(Garbage Collection)不会在主程序运行期对PermGen space进行清理，所以如果你的APP会LOAD很多CLASS的话,就很可能出现PermGen space错误。
这种错误常见在web服务器对JSP进行pre compile的时候。
如果你的WEB APP下都用了大量的第三方jar，其大小超过了jvm默认的大小(4M)那么就会产生此错误信息了。