BlogJava-在路上-随笔分类-OpenSource

Hibernate Annotation 笔记

阮步兵 — Tue, 12 Oct 2010 08:52:00 GMT

1.@Entity 标识实体
2.@Table (name = "tableName") //指定物理表

@Table(name="tbl_sky",
    uniqueConstraints = {@UniqueConstraint(columnNames={"month", "day"})}//唯一性约束
)

3.@Embeddable 被声明的类可以嵌入其他实体中
public class Address {
   private String street1;//persistent
   public String getStreet1() { return street1; }
   public void setStreet1() { this.street1 = street1; }
   private hashCode; //not persistent
}
@Embedded 在实体中嵌入一个类型：常用的像名字，地址之类的
另，使用@AttributeOverrides标识覆盖原类中的属性取值，因为原实体可能引用的是其他字段。
@Embedded
    @AttributeOverrides( {
            @AttributeOverride(name="iso2", column = @Column(name="bornIso2") ),
            @AttributeOverride(name="name", column = @Column(name="bornCountryName") )
    } )
Country bornIn;

例子：
@Entity

class User {
@EmbeddedId
@AttributeOverride(name="firstName", column=@Column(name="fld_firstname")
UserId id;
Integer age;
}
@Embeddable
class UserId implements Serializable {//此处Serializable是必须的
String firstName;
String lastName;
}

4.@Access(AcessType.PROPERTY)
必须定义getter/setter方法才能实现持久化
还有另一种取值：AcessType.FILED,可以不定义getter/setter方法，也能实现持久化
此annotation也可以定义字段。

5.主键：
   A.单键
    @Id
    @GeneratedValue (generator = "identity")
    @GenericGenerator (name = "identity", strategy = "identity")
    或者
    @javax.persistence.SequenceGenerator(
    name="SEQ_STORE",
    sequenceName="my_sequence")
    @GeneratedValue(strategy=GenerationType.SEQUENCE, generator="SEQ_STORE")
    其中：
     strategy取值为:
     AUTO - either identity column, sequence or table depending on the underlying DB
     TABLE - table holding the id
     IDENTITY - identity column
     SEQUENCE - sequence
   B.复合组键
    @Entity
class Customer {
@EmbeddedId CustomerId id;
boolean preferredCustomer;
@MapsId("userId")//user.id与customerId.userId 使用相同的值
@JoinColumns({
    @JoinColumn(name="userfirstname_fk", referencedColumnName="firstName"),
    @JoinColumn(name="userlastname_fk", referencedColumnName="lastName")
})
@OneToOne User user;
}

@Embeddable
class CustomerId implements Serializable {
UserId userId;
String customerNumber;
}

@Entity
class User {
@EmbeddedId UserId id;
Integer age;
}

@Embeddable
class UserId implements Serializable {
String firstName;
String lastName;
}


6.字段设置：
@Column(
    name="columnName";
    boolean un(2)ique() default false;
    boolean nu(3)llable() default true;
    boolean in(4)sertable() default true;
    boolean up(5)datable() default true;
    String col(6)umnDefinition() default "";
    String tab(7)le() default "";
    int length(8)() default 255;
    int precis(9)ion() default 0; // decimal precision
    int scale((10)) default 0; // decimal scale
@Transient 非持久化字段
@Basic 持久化字段
@Basic(fetch = FetchType.LAZY) basic 用于定义property的fetch属性
@Enumerated(EnumType.STRING) 标识enum persisted as String in database
@Lob blob clob字段
@Formula("obj_length * obj_height * obj_width")//自定义输出
public long getObjectVolume()

7.Mapping关系
A.一对多或者一对一：
@OneToOne(cascade = CascadeType.ALL) 一对一关系，级联关系为all
@PrimaryKeyJoinColumn或者
指定关联外键
@JoinColumn(name="passport_fk")
Passport passport，
一对一的另一端只需@OneToOne(mappedBy = "passport")，passport为前一个实体声明的名字

@OneToMany(fetch = FetchType.LAZY , mappedBy = "adProduct")
@Cascade(value = {CascadeType.ALL,CascadeType.DELETE_ORPHAN})

@OrderBy(value = "id") //排序
B.多对一：
    @ManyToOne(fetch = FetchType.LAZY)
    @JoinColumn(name="adPosition_id",nullable=false)


8.Fetch and Lazy

Annotations	Lazy	Fetch
@[One\|Many]ToOne](fetch=FetchType.LAZY)	@LazyToOne(PROXY)	@Fetch(SELECT)
@[One\|Many]ToOne](fetch=FetchType.EAGER)	@LazyToOne(FALSE)	@Fetch(JOIN)
@ManyTo[One\|Many](fetch=FetchType.LAZY)	@LazyCollection(TRUE)	@Fetch(SELECT)
@ManyTo[One\|Many](fetch=FetchType.EAGER)	@LazyCollection(FALSE)	@Fetch(JOIN)

9.Cascade

PERSIST
MERGE
REMOVE
REFRESH
DELETE
SAVE_UPDATE

10.缓存

缓存的注释写法如下，加在Entity的java类上：

@Cache(usage = CacheConcurrencyStrategy.NONSTRICT_READ_WRITE)

缓存的方式有四种，分别为：

CacheConcurrencyStrategy.NONE
CacheConcurrencyStrategy.READ_ONLY，只读模式，在此模式下，如果对数据进行更新操作，会有异常；
CacheConcurrencyStrategy.READ_WRITE，读写模式在更新缓存的时候会把缓存里面的数据换成一个锁，其它事务如果去取相应的缓存数据，发现被锁了直接就去数据库查询；
CacheConcurrencyStrategy.NONSTRICT_READ_WRITE，不严格的读写模式则不会对缓存数据加锁；
CacheConcurrencyStrategy.TRANSACTIONAL，事务模式指缓存支持事务，当事务回滚时，缓存也能回滚，只支持JTA环境。

11.No-Annotation 字段：

      If the property is of a single type, it is mapped as @Basic

      Otherwise, if the type of the property is annotated as @Embeddable, it is mapped as @Embedded

      Otherwise, if the type of the property is Serializable, it is mapped as @Basic in a column holding the object in its serialized version

      Otherwise, if the type of the property is java.sql.Clob or java.sql.Blob, it is mapped as @Lob with the appropriate LobType

阮步兵 2010-10-12 16:52 发表评论

Rule Engine之Drools

阮步兵 — Sat, 25 Sep 2010 09:48:00 GMT

对于做软件的人来说，唯一不变的就是变化。此为行业真理。而对于复杂业务系统的逻辑组件的定义不得不多考虑一下业务的可扩展性，来应对客户的变化。选择Rule Engine是一个不错的方案。

Drools 是用 Java 语言编写的开放源码规则引擎。Drools 允许使用声明方式表达业务逻辑。可以使用非 XML 的本地语言编写规则（这点很重要，本人之前曾用过自己公司的一套业务规则组件，无论是编写还是调试都很麻烦），从而便于学习和理解。并且，还可以将 Java 代码直接嵌入到规则文件中，使Drools 更加吸引人。简单的概括，就是简单使用，易于理解。而且它是免费的。

1.rule文件：
rule "rule name"
    no-loop
    when
      customer : Customer( state == CustomerState.UNCENSORED )
    then
        customer.setState(CustomerState.AUDITING);
        CustomerTask task=new CustomerTask();
        Post law=userService.getPostByPostCode(Constants.PostCode.ROOT_LAW);
        task.setAuditorPost(law);
        task.setEntityState(CustomerState.AUDITING);
        task.setEntityId(customer.getId());
        task.setEntityCode(String.valueOf(customer.getId()));
        task.setEntityType(Customer.class.getSimpleName());
        task.setTitle(customer.getName()+" test");
        taskService.assignmentTask(task);
        logger.info("CustomerTask Submit auditorTitle:" + task.getAuditorTitle());
end

这里面有个状态的条件判断state == CustomerState.UNCENSORED ，then 关键字后面的便是符合条件的处理逻辑，只要是java程度都可以看懂，比xml类的rule文件好懂了许多。

接下来
语法说明：

文件头部分：
package drools.java.demo;定义包名,等同于命名空间
import drools.java.demo.Machine;导入java类
global java.util.List myGlobalList;此关键字让规则引擎知道，myGlobalList对象应该可以从规则中访问.
function:类似于公用方法的抽象，如下定义后，各个同一文件下的rule都可以使用
function void setTestsDueTime(Machine machine, int numberOfDays) {
    setDueTime(machine, Calendar.DATE, numberOfDays);
}

rule：定义了一个规则



rule ""

*

when

*

then

*

end







 即rule的名字标识



:

常用的属性：
no-loop ：true 条件结果更改后，修改此条件且定义为no-loop:true的规则不会再重新执行。

lock-on-active：true 可以看作是no-loop的加强版，当条件结果更改后，不但修改此条件的规则不会重新执行，文件中的任何规则（其 active-lock 属性被设为 true）不会重新执行。

salience：100 使用它可以让规则执行引擎知道应该启动规则的结果语句的顺序。具有最高显著值的规则的结果语句首先执行；具有第二高显著值的规则的结果语句第二执行，依此类推。当您需要让规则按预定义顺序启动时，这一点非常重要。

其他属性的解释请见http://downloads.jboss.com/drools/docs/5.1.1.34858.FINAL/drools-expert/html_single/index.html#d0e2607

when:填写条件的地方，比如：

Cheese( type == "stilton", price < 10, age == "mature" )或



Cheese( type == "stilton" && price < 10, age == "mature" )

then:业务规则的地方，略。

2.用法

规则文件定义好后，就该是怎么使用它了

如上图，file rule定义好后，就该是如何使用它了。最重要的两个类RuleBase和WorkingMemory

下面是一个example:
public class RulesEngine {
    private RuleBase rules;
    private boolean debug = false;
    public RulesEngine(String rulesFile) throws RulesEngineException {
        super();
        try {
            // Read in the rules source file
            Reader source = new InputStreamReader(RulesEngine.class
                    .getResourceAsStream("../../rules/" + rulesFile));

            // Use package builder to build up a rule package
            PackageBuilder builder = new PackageBuilder();

            // This will parse and compile in one step
            builder.addPackageFromDrl(source);

            // Get the compiled package
            Package pkg = builder.getPackage();

            // Add the package to a rulebase (deploy the rule package).
            rules = RuleBaseFactory.newRuleBase();
            rules.addPackage(pkg);

        } catch (Exception e) {
            throw new RulesEngineException(
                    "Could not load/compile rules file: " + rulesFile, e);
        }
    }
    public RulesEngine(String rulesFile, boolean debug)
            throws RulesEngineException {
        this(rulesFile);
        this.debug = debug;
    }
    public void executeRules(WorkingEnvironmentCallback callback) {
        WorkingMemory workingMemory = rules.newStatefulSession();
        if (debug) {
            workingMemory
                    .addEventListener(new DebugWorkingMemoryEventListener());
        }
        callback.initEnvironment(workingMemory);
        workingMemory.fireAllRules();
    }
}
RulesEngine构造方法演示了如何去读入一个rule文件,并构建了一个RuleBase对象(RuleBase 是一个包含了rule文件的所有规则的集合)
executeRules方法定义了如何使用规则文件中定义的那些内容，用RuleBase构建一个WorkingMemory对象，再执行fireAllRules()方法。
WorkingMemory 代表了与rulebase链接的session会话，也可以看作是工作内存空间。如果你要向内存中插入一个对象可以调用insert()方法,同理，更新一个对象使用update()方法。WorkingMemory还有一个setGlobal()方法，用来设置规则内可以引用的对象(相当于规则的全局变量)。

3.小技巧

可以一次把所有的rule文件都载入内存中存放，这样就不用每次执行都读取文件。
如果规则文件被修改，也可以用过一个方法来判断是否需要重新载入rule文件
比如：根据文件的最后修改时间，与内存中对应对象的时间做比较
public boolean hasChange(List ruleFileList){
        for(RuleFile ruleFile:ruleFileList){
            if(!ruleFile.getLastModifyTime().equals(ruleFileMap.get(ruleFile.getFileName()).getLastModifyTime())){
                return true;
            }
        }
        return false;
    }

注：具体的helloWorld 请见http://www.ibm.com/developerworks/cn/java/j-drools/#listing12，比我说得好多了。

阮步兵 2010-09-25 17:48 发表评论

Spring之事件监听

阮步兵 — Wed, 01 Sep 2010 02:41:00 GMT

写在前面的话：spring的监听事件模型应该是观察者模式。本人项目里的应用在process方法按日期同步某个库的数据，在方法最后publish一个event事件，这个事件用于后续同步过来的数据处理。事件处理采用了spring的监听模型.这样可以做到process方法与event可以异步分离执行。（注：这个事件模型缺省使用SyncTaskExecutor来执行listener的注册event，所有该listener注册的event事件为同步执行的）。

当然，spring的这个机制还有很多应用的场景，就不一一列举了。

ApplicationEvent

事件抽象类，里面只有一个构造函数和一个timestamp。

ApplicationListener

监听接口，里面只有一个onApplicationEvent方法。需要用户自己编写ApplicationListener的实现。

ApplicationContext

spring上下文,其publishEvent方法用于通知监听器(ApplicationListener的实现)注册event时间.

publishEvent

void publishEvent(ApplicationEvent event)

Notify all listeners registered with this application of an application event.

源码解读：
1.作为ApplicationContext的实现AbstractApplicationContext.java的成员变量applicationListeners，是一个ArrayList,保存了所有的 ApplicationListener
2.利用ApplicationEventMulticaster接口里的方法来完成注册监听addApplicationListener,移除监听 removeApplicationListener，removeAllListeners，以及通知监听注册事件event：multicastEvent(ApplicationEvent event);
上面说到的publishEvent方法即使用了multicastEvent方法

SimpleApplicationEventMultucaster作为ApplicationEventMulticaster的一个实现，提供了multicastEvent的实现代码，其实就是迭代所有的监听器，用SyncTaskExecutor同步执行listener的onApplicationEvent

public void multicastEvent(final ApplicationEvent event) {

for (Iterator it = getApplicationListeners().iterator(); it

.hasNext();) {

final ApplicationListener listener = (ApplicationListener) it

.next();

getTaskExecutor().execute(new Runnable() {

public void run() {

listener.onApplicationEvent(event);
}
});
}

3.注意事项：自己编写ApplicationListener的实现时，要注意不同的监听器处理不同的事件（复写onApplicationEvent）。原因就是multicastEvent的执行原理。它是迭代执行所有的监听器 onApplicationEvent

这里是 ApplicationEventMulticaster的类分布图

abstract public class AbstractApplicationEventMulticaster implements ApplicationEventMulticaster(Code)(Java Doc)
public interface ApplicationEventMulticaster (Code)(Java Doc)

public class SimpleApplicationEventMulticaster extends

这里是ApplicationContext的类分布图
public class DefaultResourceLoader implements ResourceLoader(Code)(Java Doc)
public interface ResourceLoader (Code)(Java Doc)

abstract public class AbstractApplicationContext extends DefaultResourceLoader implements ConfigurableApplicationContext,DisposableBean(Code)(Java Doc)
public interface ConfigurableApplicationContext extends ApplicationContext,Lifecycle(Code)(Java Doc)
public interface DisposableBean (Code)(Java Doc)

public class GenericApplicationContext extends AbstractApplicationContext implements BeanDefinitionRegistry(Code)(Java Doc)
public interface BeanDefinitionRegistry (Code)(Java Doc)

abstract public class AbstractRefreshableApplicationContext extends
下面是spring自身的事件应用
1) ContextRefreshedEvent：当ApplicationContext初始化或者刷新时触发该事件。
2) ContextClosedEvent：当ApplicationContext被关闭时触发该事件。容器被关闭时，其管理的所有单例Bean都被销毁。
3) RequestHandleEvent：在Web应用中，当一个http请求（request）结束触发该事件。
4) ContestStartedEvent：当容器调用ConfigurableApplicationContext的Start()方法开始/重新开始容器时触发该事件。
5) ContestStopedEvent：当容器调用ConfigurableApplicationContext的Stop()方法停止容器时触发该事件。

阮步兵 2010-09-01 10:41 发表评论

ibatis总结(1)

阮步兵 — Mon, 30 Aug 2010 14:31:00 GMT

1.实体map.xml中配置:
主键获取方式配置,mysql

        select LAST_INSERT_ID()

动态拼接where条件


                plateId=#value#


2.config配置
typeAlias 定义类型别名

typeHandler 自定义类型转换
比如，将数据库中的1，2，3格式的数据转换为java 枚举

线程缓存等配置

         cacheModelsEnabled="true"
     enhancementEnabled="true"
     lazyLoadingEnabled="false"
     maxRequests="32"
     maxSessions="10"
     maxTransactions="5"
     useStatementNamespaces="true"
    />
   cacheModelsEnabled="true" 是否启动缓存机制
enhancementEnabled="true" 是否针对POJO启动字节码增强机制以提升getter/setter的调用效能避免使用javaReflect所带来的性能开销。同时Lazy Loading带来极大的性能提升。
maxRequests最大并发请求数(Statement数)
maxTransactions最大并发事务数
maxSessions最大Session数，即当前最大允许的并发SqlMapCliect数maxSessions设定必须界于 maxTransactions和maxRequests之间.即   maxTransactions>maxSessions>maxRequests

阮步兵 2010-08-30 22:31 发表评论

使用ORMUnit测试数据库schema与Hibernate 实体的Map关系

阮步兵 — Wed, 03 Mar 2010 06:55:00 GMT

ORMUnit下载链接：
http://code.google.com/p/ormunit/
    在做面向关系数据库的应用系统的时候，db表结构在开发过程中，可能会由于前期的设计不足导致不断的修改表结构。如果Java层面采用类似Hibernate ORM,随之对应的是maps & pojos的修改。此时修改后的简单测试就显得尤为重要。
    ORMUnit功能比较多，本文只取其少数几个类，完成上面的功能。
    1.首先改写：HibernateORMTestCase类，指定加载的hibernate.cfg.xml位置
    public abstract class HibernateORMTestCase extends TestCase {
    protected Log logger = LogFactory.getLog(getClass());
    protected SessionFactory sessionFactory;
    //Location of hibernate.cfg.xml file.
    private static String CONFIG_FILE_LOCATION = "com/mmm/china/xxx/dbtest/hibernate.cfg.xml";

    protected Configuration cfg;

    public void setSessionFactory(SessionFactory sessionFactory) {
        this.sessionFactory = sessionFactory;
    }
    /**
     * make configuration
     * @return
     */
    protected Configuration getConfiguration() {
        if (cfg == null) {
            cfg=new Configuration().configure(CONFIG_FILE_LOCATION);
        }
        return cfg;
    }

   }
    2.HibernateSchemaChecker类(检查db schema map pojo)：改写输出不符合map关系的表以及变更脚本，并增加计数功能
     List getSignificantDifferences(
            String[] script) {
        int num=0;
        List differences = new ArrayList();
        for (int i = 0; i < script.length; i++) {
            String line = script[i];

            if (line.indexOf("add constraint") == -1)
                {
                differences.add(line);
                 logger.error("DIFF_LINE>>>>>>>>>>="+line);
                }
            else{
                num++;//计算有多少个外键有问题
                logger.info("CONSTRAINT_LINE>>>>>>>>>>"+num+"="+line);
            }
        }
        return differences;
    }
      注：ORMUnit 检查CONSTRAINT 有问题，在db为sqlserver时，生成的外键约束的名称是自动命名的，与实际数据库的命名不一致，ORMUnit就认为不匹配，所以，要过滤add constraint的error信息
   3.使用HibernateSchemaTests 进行junit测试
    public class HibernateSchemaTests extends HibernateORMTestCase {

    private HibernateSchemaChecker schemaChecker;

    protected void setUp() throws Exception {
        super.setUp();
        schemaChecker = new HibernateSchemaChecker(getConfiguration(), getConfiguration().buildSessionFactory());
    }

    /**
    * Verifies all tables and columns referenced by the object/relational
    * mapping exist
    *
    * @throws Exception
    */
    public void assertDatabaseSchema() throws Exception {
        schemaChecker.assertDatabaseSchema();
    }

   }
总结：只需要三个类，即可测试数据库schema与hibernate maps & pojo的map关系是否完全匹配，事半功倍。

阮步兵 2010-03-03 14:55 发表评论

[导入]Apache CouchDB在Ubuntu下的安装

阮步兵 — Sat, 27 Feb 2010 07:38:00 GMT

先下载couchdb安装文件：版本为0.9.1

http://couchdb.apache.org/downloads.html

1开始安装依赖包

sudo apt-get build-dep couchdb

sudo apt-get install libmozjs-dev libicu-dev libcurl4-gnutls-dev libtool

2.解压缩

tar -zxvf apache-couchdb-0.9.1.tar.gz

3.开始安装

cd apache-couchdb-0.9.1

./configure

make

sudo make install

4.启动couchdb

sudo couchdb

5.访问:http://127.0.0.1:5984/_utils/

启动报错：

$ bin/couchdb















Apache CouchDB 0.9.0a691361-incubating (LogLevel=info) is starting.







{"init terminating in do_boot",{{badmatch,{error,shutdown}},[{couch_server_sup,start_server,1},







{erl_eval,do_apply,5},{erl_eval,exprs,5},{init,start_it,1},{init,start_em,1}]}}







Crash dump was written to: erl_crash.dump







init terminating in do_boot ()







查了一下官方wiki:







原来是安装文件夹的权限问题















解决办法：







sudo adduser couchdb







chown -R couchdb:couchdb /usr/local/etc/couchdb 







chown -R couchdb:couchdb /usr/local/var/lib/couchdb 







chown -R couchdb:couchdb /usr/local/var/log/couchdb 







chown -R couchdb:couchdb /usr/local/var/run 







chmod -R 0770 /usr/local/etc/couchdb 







chmod -R 0770 /usr/local/var/lib/couchdb 







chmod -R 0770 /usr/local/var/log/couchdb 







chmod -R 0770 /usr/local/var/run















再此启动，看到欢迎界面，所有的testsuite run success,大功告成！

文章来源:http://guming.blogbus.com/logs/45898514.html

阮步兵 2010-02-27 15:38 发表评论