sober帮助

作者:陈原 mail:cayu@gzec.com.cn QQ:39793751 home: http://www.jspx.net

1.简介

首先在orm这块不得不提hibernate它引导了orm这块的进步,搞java数据库的都不太可能没听说过它.我也使用了很长时间的hibernate但hibernate有不少让我感觉不满意的地方,很多人说hibernate慢,其实不然hibernate能够做出很快的数据库应用来,但它的设计上太为了oo而oo,制造了很多的陷阱,让不熟悉的人一用就头痛.特别是在映射和延时加载上,如果你完全的按照oo来设计你的数据库,不是慢就是问题.而且最不舒服的地方hibernate的缓存,用了和没用一样,hibernate值在缓存中保存了数据记录的ID并没有实体,下一次查询的适合在一个一个的查询出来,痛苦的事情. Amber一个很有研究价值的orm,sober就是模仿了它的映射配置方式,感觉不错resin主推它.ibatis 是 apache的orm从配置和速度上来说不错,但很多人对它的分页愤愤不平.sober提供了它的SQL映射配置方式查询.在看过这些orm后最后我决定自己写一个orm就是sober.让简单的数据,保存,编辑,增加如同hibernate一样方便,配置如同amber一样人性,复杂的SQL使用ibatis的映射方式完成.严格的来说sober只是一个JDBC扩展。它能够让你简单方便的操作数据

和hibernate的不同点说明.很多人感觉hibernate不好用的问题在于对hibernate不了解。很多人想当然的使用JDBC的概念来使用hibernate.这是一个错误的开始。因为hibernate 的宣传就是让你不必了解细节直接操作数据，但这样就会出现不少细节上的问题。因为hibernate并不是一个jdbc的简单扩展，他包括了映射管理和缓存管理,HQL转换，内部还包括了复杂统计。如果你不了解hibernate又使用了不少hibernate的高级特性还在做复杂的操作，很可能就掉入那些不小心就会犯的错误中。在hibernate 后期版本中感觉缓存功能改进了不少，要好用多了，但那个包又大又多有占内存，感觉只时候中型项目。
正是这样所以有了写Sober的想法，Sober是一个真正JDBC的扩展，内部没有复杂的缓存，数据统计这些。
只是对JDBC直接的操作。让你的操作和JDBC没区别，同时又既有了hibernate的简便性。
就用JDBC的概念来使用没有一点问题。

2.功能说明

标签配置数据库映射,简单,直观.可以自动建表.
数据处理直接连接到JDBC保存速度快捷.
参数控制映射对象是否加载,更灵活,快速.查询细粒度.
多种查询处理方式.可以使用hibernate的Criteria方式,sql查询方式和Ibatis的sql映射配置方式.还提供了简单的ssql表达式查询方式.
类似hibernate的数据库适配器,Dialect支持主流数据库.采用Criteria方式,目前对数据库Postgresq 8.3xl以上版本和mysql支持比较好.
提供事务支持JDBCTransaction和JTATransaction.让你能够应用在复杂的高安全环境.

3.配置使用说明

下边我们使用sioc配置方式, 当然你也可以使用代码写程序实现配置.

首先你需要配置一个数据源,sober提供了一个数据库连接池,速度和稳定性在2.1版本后都很优秀了。你也可以使用其他的数据源比如c3p0
Jspx连接池的比较和使用可看这里Jspx连接池帮助
c3p0数据连接池配置例子(当sober提供的数据源不能够在满足要求的时候才推荐使用)

下边例子演示了c3p0的连接池配置,换一下类命就可以了很方便。 (使用的时候一个就可以了)

下边是sober的环境配置,com.jspx.sober.config.SoberMappingBean是配置bean,使用单列运行

<bean id="jspxSoberFactory" class="com.jspx.sober.config.SoberMappingBean" singleton="true">
        
        <string name="databaseName">${dialect}</string>
        
        
        <ref name="dataSource">jspxDataSource</ref>
        
        
        
        
        <boolean name="valid">false</boolean>
        
        <int name="maxRows">10000</int>
        
        <string name="showsql">${show_sql}</string>
        
        <array name="mappingResources" class="string">
            <value>*.sqlmap.xml</value>
        </array>
    </bean>
    
    <bean id="com.jspx.sober.GenericDAO" class="com.jspx.sober.GenericDAO" singleton="true">
          <ref name="soberFactory">jspxSoberFactory</ref>
    </bean>

4.jdk1.5标签映射配置说明

标签说明

标签	参数说明
Column	notNull:是否不允许为空,option:选择范围 ,valid:验证,defaultValue:默认值,length:长度 caption:字段的描述 boolean notNull() default false; 是否为空 String option() default ""; 选择范围,例如 option="1:yes;0:no" String valid() default ""; String defaultValue() default ""; //默认值,映射到数据库 int length() default 0; // 长度,映射到数据库
Id [boolean auto() default true; String type() default "seq"; int length() default 16; //max 19 long max() default Long.MAX_VALUE; int min() default 0;int next() default 1;boolean dateStart() default false;]	auto:是否自动生成ID,type:生成方式 s seq:系统默认生成 yyyyMMddhhss + 序列,类型可以是long 和 String seq:的时候使用下边的配置创建系列 uid:jdk1.5 默认生成 b2a53eef-3a29-44ff-bca5-72abc9568785,类型可以是String uid:为long类型使用 UUID getMostSignificantBits 生成 serial:数据库自动增加果 auto=false 就会 type＝serial 更具数据库得到 auto=true 如果里边已经有值，将不创建id,否则更具type生成
Nexus	mapping:映射关系，name:自己表的字段,targetName:对应的数据字段,targetEntity:对应的类,term: 条件使用 ssql表达式,orderBy:排序
Table	name:表名称映射到数据库,caption:说明性文字
CalcUnique	sql:统计的sql,entity用到的实体,eg: @CalcUnique(caption = "说明", sql = "SELECT COUNT(*) FROM ${entity1} WHERE matterId=${id}", entity ={Remark.class} )

参数说明
Id标签的type有下边几种生成方式
seq:系统默认生成 yyyyMMddhhss + 序列,类型可以是long 和 String
uid:jdk1.5 默认生成 b2a53eef-3a29-44ff-bca5-72abc9568785,类型是String
uid:为long类型使用 UUID getMostSignificantBits 生成
serial:数据库自动增加1

CalcUnique标签
sql = "SELECT COUNT(*) FROM ${entity1} WHERE matterId=${id}", entity ={Remark.class}
entity1:是实体1,你要用到是实体，使用1,2,3方式,配合freemaker语言表示
entity:是一个数组，包括了你在本sql中会用到的实体
Column标签

Date类型的时候，如果不允许为空，默认为当前时间.默认都使用日期时间类型。

Nexus标签

表示映射关系,mapping关系可以在MappingType得到定义。
public static final String ManyToOne = "ManyToOne";
public static final String OneToOne = "OneToOne";
public static final String OneToMany = "OneToMany";

我们来配置写两个bean分别映射到数据库.并且里边配置一对多和多对一的方式.演示例子使用投票的关系,一个投票主题表VoteTopic 和投票选项Vote 我们使用两个表来分别保存数据,很象Amber的映射配置吧.
例子1.我们来配置一个简单的bean来演示.

//运行的时候数据中会创建testBean这个表名称,变量名称将作为表的字段名称
@Table(name = "testBean")
public class TestBean implements Serializable
{
    public TestBean()
    {

}

@Id(auto = true) //ID使用自动创建
    @Column(caption = "ID", length = 50, notNull = true)
    private String id = "";

public String getId()
    {
        return id;
    }

public void setId(String id)
    {
        this.id = id;
    }

@Column(caption = "数量",valid="indexOfArray([10,20])",notNull=true) //caption显示,valid="indexOfArray([10,20])表示只能是10,20两个数值.
    private int mum = 0;

public int getMum()
    {
        return mum;
    }

public void setMum(int mum)
    {
        this.mum = mum;
    }

@Column(caption = "创建日期")
    private Date createDate = new Date();

public Date getCreateDate()
    {
        return createDate;
    }

public void setCreateDate(Date createDate)
    {
        this.createDate = createDate;
    }

@Column(caption = "内容", length = 250,valid="isLengthBetween(10,100)",notNull=true) //数据库将创建能够保存250字符的字段, isLengthBetween(10,100)表示长度范围在10-100之间
    private String topicText = null;

public String getTopicText()
    {
        return topicText;
    }

public void setTopicText(String topicText)
    {
        this.topicText = topicText;
    }
}

如果不是在web服务器里边运行,作为应用运行的化,我们使用下边语句来初始化应用.

TestBean testBean = new TestBean();
     testBean.setMum(11);//如果是10,20就可以保存成功，否则将会报错，不允许保存
     testBean.setTopicText("topicText"); //lengthBetween[10-20],文字长度在10-20范围，否则报错
     try
     {
             //sober当开启验证方式,sober会更具TestBean的校验来验证数据,不成功就会异常你可以通过ValidException得到详细信息
            genericDAO.save(testBean, false);  //保存数据,这里返回被操作的记录条数1
            //如果你的ID是自动生成的,那边保存成功后自动生成的ID已经被放入testBean中了.
            genericDAO.delete(testBean);//这里返回被操作的记录条数
     } catch (ValidException e)  {
           Map mp = e.getValidMap();
           for (Object key : mp.keySet())
           {
             	//这里将会打印验证错误的信息
                System.out.println("--------------" + key + "=" + mp.get(key));
           }
    }     
 }

例子2:下边我们来做一个有映射关系的例子,一个投票的设计.
下边是投票的说明主信息保存bean

@Table(name = "jspx_votetopic", caption = "投票")
public class VoteTopic implements Serializable
{
    public VoteTopic()
    {

}

@Id(auto = true)
    @Column(caption = "ID号", length = 50, notNull = true)
    private String id = "";

@Column(caption = "选项", length = 250, notNull = true, defaultValue = "")
    private String topicText = "";

@Column(caption = "类型", option = "0:单选;1:多选", notNull = true, defaultValue = "0")
    private int voteType = 0;

@Column(caption = "表示图", option = "0:条型;1:柱状;2:饼型;4:线型", notNull = true, defaultValue = "0")
    private int shape = 0;

@Column(caption = "重复投票", option = "0:否;1:是", notNull = true, defaultValue = "0")
    private int repeat = 0;

@Column(caption = "投票结束时间", notNull = true)
    private Date endDate = DateUtil.getYear(2);

@Column(caption = "排序时间", notNull = true)
    private Date sortDate = new Date();

@Column(caption = "排序",length = 2,notNull = true, defaultValue = "0")
    private int pollLook = 0;

@Column(caption = "排序", notNull = true, defaultValue = "0")
    private int sortType = 0;

@Column(caption = "最后操作时间", notNull = true)
    private Date lastDate = new Date();

@Nexus(mapping = MappingType.OneToMany, name = "id", targetName = "topicId", orderBy = "sortType:A", targetEntity = VoteItem.class)
    private List<VoteItem> voteItemList = new LinkedList<VoteItem>();

@Column(caption = "命名空间", length = 50, notNull = true)
    public String namespace = "";

public String getId()
    {
        return id;
    }

public void setId(String id)
    {
        this.id = id;
    }

public String getTopicText()
    {
        return topicText;
    }

public void setTopicText(String topicText)
    {
        this.topicText = topicText;
    }

public int getVoteType()
    {
        return voteType;
    }

public void setVoteType(int voteType)
    {
        this.voteType = voteType;
    }

public int getRepeat()
    {
        return repeat;
    }

public void setRepeat(int repeat)
    {
        this.repeat = repeat;
    }

public int getShape()
    {
        return shape;
    }

public void setShape(int shape)
    {
        this.shape = shape;
    }

public String getNamespace()
    {
        return namespace;
    }

public void setNamespace(String namespace)
    {
        this.namespace = namespace;
    }

public Date getSortDate()
    {
        return sortDate;
    }

public void setSortDate(Date sortDate)
    {
        this.sortDate = sortDate;
    }

public int getSortType()
    {
        return sortType;
    }

public void setSortType(int sortType)
    {
        this.sortType = sortType;
    }

public Date getLastDate()
    {
        return lastDate;
    }

public void setLastDate(Date lastDate)
    {
        this.lastDate = lastDate;
    }

public Date getEndDate()
    {
        return endDate;
    }

public void setEndDate(Date endDate)
    {
        this.endDate = endDate;
    }

public List<VoteItem> getVoteItemList()
    {
        return voteItemList;
    }

public void setVoteItemList(List<VoteItem> voteItemList)
    {
        this.voteItemList = voteItemList;
    }

public int getPollLook()
    {
        return pollLook;
    }

public void setPollLook(int pollLook)
    {
        this.pollLook = pollLook;
    }

public int getSumPoint()
    {
        int resutl = 0;
        for (VoteItem vv : getVoteItemList())
        {
            resutl = resutl + vv.getVotePoint();
        }
        return resutl;
    }
}

Vote 投票选项表

@Table(name = "jspx_voteitem", caption = "投票选项")
public class VoteItem implements Serializable
{
    @Id(auto = true,length=20)
    @Column(caption = "ID号", length = 50, notNull = true)
    private String id = "";

@Column(caption = "排序", notNull = true, defaultValue = "0")
    private int sortType = 0;

@Column(caption = "投票主题的ID", length = 50, notNull = true)
    private String topicId;

@Nexus(mapping = MappingType.ManyToOne, name = "topicId", targetName = "id", targetEntity = VoteTopic.class)
    private VoteTopic voteTopic;

@Column(caption = "投票选项说明", length = 50, notNull = true)
    private String title = "";

@Column(caption = "票数", notNull = true, defaultValue = "0")
    private int votePoint = 0;

public VoteItem()
    {

}

public String getId()
    {
        return id;
    }

public void setId(String id)
    {
        this.id = id;
    }

public int getSortType()
    {
        return sortType;
    }

public void setSortType(int sortType)
    {
        this.sortType = sortType;
    }

public VoteTopic getVoteTopic()
    {
        return voteTopic;
    }

public void setVoteTopic(VoteTopic voteTopic)
    {
        this.voteTopic = voteTopic;
    }

public String getTopicId()
    {
        return topicId;
    }

public void setTopicId(String topicId)
    {
        this.topicId = topicId;
    }

public String getTitle()
    {
        return title;
    }

public void setTitle(String title)
    {
        this.title = title;
    }

public int getVotePoint()
    {
        return votePoint;
    }

public void setVotePoint(int votePoint)
    {
        this.votePoint = votePoint;
    }

/**
     * scale
     * 得到投票比例
     *
     * @return double
     */
    public Float getScale(int sum)
    {
        if (sum<=0) return (float) 0;
        return (NumberUtil.mul(NumberUtil.div(votePoint, sum).doubleValue(), 100)).floatValue();
    }
}

下边我们来看看如何操作数据,保存的时候使用事务功能
2.1版本以前没有事务功能，2.1版本后添加了JDBC事务和JTA事务功能。

public static void main(String arge[]) throws Exception
 {
     //我们使用下边语句来初始化应用
	 JspxNetApplication.autoRun();
     
     //通过环境得到Sioc 的bean工厂
	 BeanFactory beanFactory = EnvFactory.getBeanFactory();
	 SoberSupport genericDAO = (SoberSupport) beanFactory.getBean(GenericDAO.class.getName());
     
     ////////下边为保存数据
     Transaction transaction = genericDAO.createTransaction();
     //创建事务JDBC事务和JTA事务都可以跨DAO
	 try
      {
            transaction.begin();//事务开始
            for (int i = 0; i <= 3; i++)
            {
                VoteTopic tbx = new VoteTopic();
                tbx.setTopicText("放入测试" + i);
                List<VoteItem> voteItemList = new LinkedList<VoteItem>();
                VoteItem v = new VoteItem();
                v.setTitle("子A" + i);
                voteItemList.add(v);
                v = new VoteItem();
                v.setTitle("子B" + i);
                voteItemList.add(v);
                tbx.setVoteItemList(voteItemList);
                genericDAO.save(tbx, true); //这里的true,表示是否保存映射对象
            }
            transaction.commit(); //事务提交
      } catch (Exception e) {
            transaction.rollback(); //事务回滚
            e.printStackTrace();
     }

//删除对象,例如我们要删除VoteTopic的id为00000000000000000029的记录
     VoteTopic v = new VoteTopic();
     v.setId("00000000000000000029");
     int delNum = genericDAO.delete(v, true); //这里true表示是否删除映射对象
     /*
	  也可以这样不删除映射对象
      genericDAO.delete(VoteTopic.class, "00000000000000000029")
     */    
     /*
     更新        
        VoteTopic voteTopic = (VoteTopic) genericDAO.get(VoteTopic.class, "VoteTopic的ID", false);         //这里的false表示不载入映射对象
        voteTopic.setTopicText("保存编辑新的内容");
        genericDAO.update(voteTopic); 更新对象
     */
 }

看看是不是很象hibernate,使用他们完成基本的数据操作很舒服吧.而且粒度更细一些,更好控制一些.

下边我们来看看 ibatis方式的映射sql查询?看上边配置文件载入使用的是*..sqlmap.xml,所以在会在启动的时候自动载入sql配置文件 votetopic.sqlmap.xml
使用的是Freemaker 模版(当应用在存在复杂的多表时推荐使用这种查询方式,因为这种查询方式比较灵活,而且优化的sql能够很好的提高性能)
votetopic.sqlmap.xml
假设包路径为:jspx/apply/table 在使用的时候更改为你相应的路径
查询列表模版中放入了默认的几个变量
databaseName:数据库名,方便你实现跨数据库的映射配置
currentPage:当前页
totalCount:每页显示行数
loadChild:是否导入映射对象(优化查询)
rollRows:是否滚动到行

//创建SQL映射查询器
        SqlMapClient sqlMap = genericDAO.buildSqlMap();
        //查询后是Map方式返回,参数说明:SQl配置的命名空间(<sqlMap namespace="jspx.apply.table.VoteTopic">和这里对应),
        //getVoteTopicMap 是查询的ID( <query id="getVoteTopicMap" class="map">)
        //第1页,每页2行,是否载入映射对象,是否使用滚动到行(如果你在配置的 SQL中不需要滚动到行了,就设置为false),
        //例如: SELECT * FROM VoteTopic WHERE voteType=${voteType} limite ${currentPage},${totalCount}
        //这时候就不需要在滚动到行了.
         List>  list = sqlMap.queryForList(VoteTopic.class,"getVoteTopicMap", voteTopic, 1, 2, true,true);
        for (DataMap valueMap : list)
        {
                for (Object keys : valueMap.keySet())
                {
                    //字段=值
                    System.out.println(keys + "=" + valueMap.get(keys));
                }
        }
        
        //查询返回单个对象
        sqlMap.getUniqueResult(...);
        //更新 
        sqlMap.update(...);
        //执行SQL
        sqlMap.execute(...);
        //DataMap 是扩展的HashMap 能够方便的转换数据类型
        List<DataMap>  list = sqlMap.queryForList(VoteTopic.class,"getVoteTopicMap", voteTopic, 1, 2, true,true);
        for (DataMap valueMap : list)
        {
                for (Object keys : valueMap.keySet())
                {
                    //字段=值
                    System.out.println(keys + "=" + valueMap.get(keys));
                }
        }

最后还提供了hibernate的Criteria扩展方法.用法和hibernate的差不多(推荐一般查询使用方法)

你也可直接使用sql,来完成查询,更新
查询VoteTopic中2页每页5个数据,最后的false表示不载入映射对象.(更具应用时间需要)
List list = genericDAO.queryForList(VoteTopic.class, "select * from ${table_name}", null, 2,5, false);

保持读取图片的例子

下边在做一个保持读取图片的例子,我们先定义一个实体bean

import com.jspx.sober.annotation.Column;
import com.jspx.sober.annotation.Id;
import com.jspx.sober.annotation.Table;

import java.io.InputStream;
import java.io.Serializable;
import java.util.Date;

@Table(name = "testBean2",caption="保存图片")
public class TestBean2 implements Serializable
{
    public TestBean2()
    {

}

@Id(auto = true)
    @Column(caption = "ID", notNull = true)
    private int id = 0;

public int getId()
    {
        return id;
    }

public void setId(int id)
    {
        this.id = id;
    }

@Column(caption = "数量")
    private int mum = 0;

public int getMum()
    {
        return mum;
    }

public void setMum(int mum)
    {
        this.mum = mum;
    }

@Column(caption = "创建日期")
    private Date createDate = new Date();

public Date getCreateDate()
    {
        return createDate;
    }

public void setCreateDate(Date createDate)
    {
        this.createDate = createDate;
    }

@Column(caption = "图片")
    private InputStream image = null; //这个字段将保存图片

public InputStream getImage()
    {
        return image;
    }

public void setImage(InputStream image)
    {
        this.image = image;
    }
}

在这里是保存图片,和查询出来的代码

TestBean2 tb = new TestBean2();
        //放入图片假设图片路径为d:/JD040.jpg ,当然也可以是别的文件
        tb.setImage(new java.io.FileInputStream(new File("d:/JD040.jpg")));
        //放入其他数据
        tb.setMum(18);
        //保持到数据库

soberTemplate.save(tb); //保存到数据库中
        System.out.println(tb.getId());
        //------------------------

//再查询输出来
        TestBean2 tbb = (TestBean2) genericDAO.get(TestBean2.class, tb.getId());
        //输出到d:/test.gif文件，如果是在网页上可以直接输出

//保存到d:/test.jpg文件
        InputStream in = tbb.getImage();
        OutputStream fon = new java.io.FileOutputStream(new File("d:/test.jpg"));
        byte[] data = new byte[1024];
        int nbRead;
        try
        {
            while ((nbRead = in.read(data)) >= 0)
            {
                if (nbRead >= 0)
                {
                    fon.write(data, 0, nbRead);
                }
            }
            in.close();
            fon.close();
        } catch (IOException e)
        {
            e.printStackTrace();
        }

下边我们在来介绍使用标签方式annotation来定义DAO查询的方法.不过这种方式比较简单,对于逻辑复杂的处理有些不太好. 但设计出发点是比较好的.因为需要代码不多,我就将他实现了,配合上边的方法使用也不错.实际大型的应用在不推荐. 配置继续上边的基本配,添加如下配置

com.jspx.example.AnonDemoDAOImpl.java 代码如下

import com.jspx.sober.jdbc.JdbcOperations;
import com.jspx.sober.annotation.Query;
import com.jspx.sober.annotation.Update;
import com.jspx.sober.annotation.Rollback;
import com.jspx.example.dao.AnonDemoDAO;
import java.util.List;
import java.util.Map;

public class AnonDemoDAOImpl  extends JdbcOperations implements AnonDemoDAO
{
    public AnonDemoDAOImpl()
    {
        
    }

//这里演示使用sql查询
    @Query(entity= VoteTopic.class,sql="select * from ${table_name}")
    public List getTestList(Object[] parms,int ipage,int icount)
    {
        return null;
    }

//这里演示使用sql查询
    @Query(id="getVoteTopic",namespace="jspx.apply.table.VoteTopic")
    public List getTestList2(Object[] parms,int ipage,int icount)
    {
        return null;
    }
    
    @Rollback() //表示使用事务处理
    @Update(entity= VoteTopic.class,sql="update ${table_name} set topicText=? where id=?")
    public int getTestUpdate(Object[] parms)
    {
        /*这里什么也不用写,因为这里的程序更本就不会执行,
          这里使用数组的方式传递参数        
        */
        return 0;
    }

@Update(entity= VoteTopic.class,sql="update ${table_name} set topicText='${topicText}' where ${primary_key}='${id}'")
    public int getTestUpdate2(Map valueMap)
    {
        /*这里使用map方式传递参数,使用Freemaker解析 */
        return 0;
    }
    
    //当然你也可以不加标签,就可以直接调用了.
    
}

AnonDemoDAO 接口的代码如下

下边我们就可以操作数据了.