Ebean Demo

ebean  orm框架，其作者觉得hibernate的bean管理会话管理。难以在短时间明确，就自己搞了一套，就成了如今的ebean。

ebean被一些开发人员这觉得是一把瑞士军刀。能够看出一些程序猿对ebean的高度评价。以下是一些ebean的特点总结

     1.简单易于学习和使用（简化hibernate，仅仅有一个jar包）
     2.使用标准的JPA annotation，即： @@OneToMany等。
     3.提供Sessionless API，也就是说没有merge，flush等方法。（这也是Ebean与Hibernatet等ORM的重要差别之中的一个）；
     4.通过Autofetch*进行自己主动查询调优。支持级联保存和删除。
     5.链式查询语言
     6.L1、L2 缓存
     7.集成Lucene文本搜索。

以下是一段使用ebean的代码例子

package models;

import com.avaje.ebean.Ebean;
import com.avaje.ebean.annotation.Formula;
import com.avaje.ebean.annotation.Transactional;
import com.avaje.ebean.cache.ServerCacheManager;
import play.data.validation.Constraints;
import play.db.ebean.Model;
import util.Util;


import javax.persistence.*;
import java.util.List;


/**
 * Created by wangjun on 14-3-26.
 */
@Entity // ebean 所用的注解是jpa
//@Table(name = "user")
public class User extends Model {


    @Id //@EmbeddedId 复杂id
    public Long id; //默认命名约定：first_name maps to firstName
    @Constraints.Required
    public String username;
    //@Column(name = "password")
    public String password;
    @ManyToOne(cascade = CascadeType.ALL)
    //会载入address_id ,但不会载入整个address,这个和hibernate有差别。Ebean的延迟载入对于性能的影响不打，默认EAGER。最好打开
    public Address address; //出身地
    /*@OneToOne
    public User mate;//配偶*/
   /* @OneToMany(cascade = CascadeType.PERSIST)
    public List<Address> addresses;//曾居住地  会在address端要求user_id 字段。能够用？ManyToMany取代*/
    @ManyToMany(fetch = FetchType.LAZY, cascade = CascadeType.DETACH)
//cascade = CascadeType.ALL 级联情况下会自己主动插入car个中间表数据,默认不级联 。对于一些级联更新非常是有必要
    public List<Car> cars;
    @Formula(select = "(select count(*) from user_car c where c.user_id = ${ta}.id )")
    // 计算拥有车的数量 ${ta} 代表表的别名 ，还能够写join
    public int carSize;


    //@Transient




    //会满足上述条件后在调用此方法，全局验证
    public String validate() {
        if (username.equals("1")) {
            return "Invalid email or password";
        }
        return null;
    }


   /* public List<ValidationError> validate() {
        if ( username.equals("1")) {
            return null;
        }
        return null;
    }


    public Map<ValidationError> validate() {
        if ( username.equals("1")) {
            return null;
        }
        return null;
    }*/


    public static Model.Finder<Long, User> find = new Model.Finder(Long.class, User.class);


    //============自己主动抓取測试==start=================
    public static User findById(Long id) {
        User user = find.byId(id); //不抓取car,LAZY不select address_id
        return user;
    }


    public static User findById(Long id, int loadType) {
        User user = find.byId(id); //不抓取car,不抓取address
        String name = null;
        int size = 0;
        if (loadType == 1)
            name = user.address.province; //每次都会载入user
        else if (loadType == 2)
            size = user.cars.size(); //每次都会载入car
        Util.report(name);
        Util.report(size + "");
        return user;
    }




    //连表查询測试
    public static User findByIdLoadAddress(Long id) {
        return find.fetch("address").fetch("cars").where().eq("id", id).findUnique(); // fetch= 生成join查询 不用fetch延迟载入，且不会生成join查询；
    }


    /**
     * *
     * TxType Descriptions
     * TxType Description
     * REQUIRED Runs in a Transaction. Will use an existing transaction if it exists, otherwise will create a new Transaction.
     * REQUIRES_NEW Runs in a new Transaction. If a current transaction exists it will be suspended.
     * MANDATORY Runs in the existing Transaction. If there is no current existing transaction an exception is thrown.
     * SUPPORTS Use a transaction if it already exists. If it does not then the method runs without a transaction.
     * NOT_SUPPORTS Always runs without a transaction. If one already exists then it is suspended.
     * NEVER Always runs without a transaction. If one already exists then it throws an exception.
     *
     * @param type
     */
    @Transactional// 打开事务。或通过beginTr....  endTr.. 或TxRunnable
    public void saveUser(int type) {
        Util.report("=============saveUser==start===============================");
        if (type == 0) { //不级联情况保存
            this.address.save(); // 保存用户前将用户输入的出生地也保存到数据库
            this.save(); // 保存用户数据
            this.saveManyToManyAssociations("cars"); //保存中间表
        } else if (type == 1) { //假设设置级联car
            this.save(); // 会级联插入car和中间表数据
        }
        Util.report("===============saveUser===end============================");
    }


    public void deleteUser(Long id) {
        Ebean.delete(User.class, id);
    }




    /**
     * *********************other test*********************
     * public void updateUser() {
     * this.update();
     * }
     * <p/>
     * //批量操作
     * public void deleteUser(List<User> users) {
     * Ebean.delete(users);//批量删除
     * Ebean.save(users);//批量保存
     * }
     * <p/>
     * public void deleteUser() {
     * this.delete();
     * }
     * ***************
     */


    //L1 測试 事务级缓存或持久化上下文缓存
    public static User find() {
        Ebean.beginTransaction();
        Car car1 = Car.find.byId(Long.valueOf(7));
        Car car2 = Car.find.byId(Long.valueOf(8));
        User user = User.findById(Long.valueOf(45));
        if (user.cars.get(0).id == 7) { // 查到的ｃａｒ实例属于同一个实例
            Util.report((user.cars.get(0) == car1) + "");
        } else if (user.cars.get(0).id == 8) {
            Util.report((user.cars.get(0) == car2) + "");
        }
        Ebean.endTransaction();
        return user;
    }


    //L2 測试　　bean　cache and query cache
    public static Address findAddress() {//手动指定使用缓存。同一时候设置为仅仅读。能够在model使用注解指定缓存策略。假设有改动缓存的bean，会自己主动维持缓存
        Address address_ = Ebean.find(Address.class).setUseCache(true).setReadOnly(true).setId(56).findUnique();
        List<Address> addressList = Ebean.find(Address.class).setUseQueryCache(true).setReadOnly(true).findList();
        Util.report(addressList.size() + "");
        return address_;
    }


    // 測试　不用cache 查询10000次　
    public static Car findCar() {
        Car car = null;
        for (int i = 0; i < 100000; i++) {
            Car car_ = Ebean.find(Car.class, 1);
            Util.report((car == car_) + "");
            car = car_;
        }
        return car;
    }




    // 測试　不用cache 查询10000次　
    public static Car findCar2() {
        Car car = null;
        for (int i = 0; i < 10000; i++) { // 仅仅查1次
            Car car_ = Ebean.getReference(Car.class, 1); // getReference 仅仅会载入创建存在id属性的bean。不会查询数据库。当得到这个bean，用id外的其他属性就会引发查询
            Util.report((car == car_) + "");
            car = car_;
        }
        return car;
    }




    //L1 測试　 查询10000次　
    public static Address findAddressInL1() { // 仅仅查1次
        //      Address address_ = Ebean.find(Address.class, "56");
        Address address = null;
        Ebean.beginTransaction();
        for (int i = 0; i < 10000; i++) {
            Address address_ = Ebean.find(Address.class, 56);
            Util.report((address == address_) + "");
            address = address_;
        }
        Ebean.endTransaction();
        return address;
    }


    //L2 測试　　查询10000次
    public static Address findAddressInL2() {
        Address address = null;
        for (int i = 0; i < 10000; i++) { // 查了数据库
            Address address_ = Ebean.find(Address.class, 56);
//            Address address_ = Ebean.find(Address.class).setUseCache(true).setReadOnly(true).setId(56).findUnique();
            Util.report((address == address_) + "");
            address = address_;
        }
        return address;
    }


    //L2 測试　　查询10000次
    public static Address findAddressInL22() {
        Address address = null;
        for (int i = 0; i < 10000; i++) { // 測试查了数据库
            // Address address_ = Ebean.getReference(Address.class,56);
            Address address_ = Ebean.find(Address.class).setUseCache(true).setReadOnly(true).setId(56).findUnique();
            Util.report((address == address_) + "");
            address = address_;
        }
        return address;
    }


    //L2 測试　　抓取Address10000次  当第一次查询的时候会查询address，之后会从缓存取
    public static Address findAddressInL222() {
        Address address = null;
        for (int i = 0; i < 10000; i++) { // 測试查了数据库
            User user = User.findById(Long.valueOf(41));
            Address address_ = user.address; // 数据从缓存内得到
            Util.report((address == address_) + (address == null ?

null : address.province));
            address = address_;
        }
        return address;


    }


    /**
     * **
     * Handling External Modification (
     * via stored procedures etc
     * )
     * When you save/delete beans via Ebean.save() and Ebean.delete() etc Ebean will
     * automatically maintain its cache (removing cached beans and cached queries as
     * appropriate). However, you may often find yourself modifying the database outside of
     * Ebean.
     * For example, you could be using other frameworks, your own JDBC code, stored
     * procedures, batch systems etc. When you do so (and you are using Ebean caching) then
     * you can inform Ebean so that it invalidates appropriate parts of its cache.
     */
    public void test() {
        boolean inserts = true;
        boolean updates = true;
        boolean deletes = false;
        // inform Ebean that some rows have been inserted and updated on address table Ebean will maintain the appropriate caches.
        Ebean.externalModification("address", inserts, updates, deletes);
        // clearAll() caches via the ServerCacheManager ...
        ServerCacheManager serverCacheManager = Ebean.getServerCacheManager();
        // Clear all the caches on the default/primary EbeanServer
        serverCacheManager.clearAll();
        // clear both the bean and query cache for Country beans ...
        serverCacheManager.clear(Address.class);
        // Warm the cache of Country beans
        Ebean.runCacheWarming(Address.class);
    }




    @Override
    public String toString() {
        String result = "";
        if (address == null)
            result.concat("address:null");
        else
            result.concat("address:").concat(address.province).concat("-").concat(address.town);
        return result;
    }


}