s2dao

s2dao是基于seasar2的orm框架，使用简单且功能比较强大。官方网站为http://s2dao.seasar.org/，中英日文档皆有。
如果对hibernate望而生畏，而只是寻找一个替代jdbc的工具的话，s2dao算是一个不错的选择。某种程度上来讲，s2dao可能会比较像ibatis(笔者没有使用过ibatis)。

具体编码来说，基本上是一个interface(相当于DAO)对应一个javabean。这里的javabean不是pojo，不具备持久性，只是作为dao方法返回值的容器，所以可以很方便的实现复杂的多表检索。
interface的具体方法体不用自己手写，通过系统的interceptor可自动填充并实现。

下面对使用做具体介绍。本文使用的s2dao版本为1.0.49。
DB中有三个表：


1.单表

Example.java为Example表的容器类(s2dao习惯称之为DTO，虽然这个称呼不是很恰当)
1 package com.hg.s2dao.dto;
2
3 import org.seasar.dao.annotation.tiger.Bean;
4
5 @Bean(table = "EXAMPLE")
6 public class Example {
7
8 private String id;
9 private String name;
10
11 public String getId() {
12 return id;
13 }
14
15 public void setId(String id) {
16 this.id = id;
17 }
18
19 public String getName() {
20 return name;
21 }
22
23 public void setName(String name) {
24 this.name = name;
25 }
26
27 public String toString() {
28 return "id: " + id + " name: " + name;
29 }
30
31 }使用@Bean注释表明此DTO所对应的DB表名，剩下的就是字段和getter、setter了。
※注：当进行多表检索时，@Bean指定其中的一个table即可。

接下来是DAO，代码大体比较易懂。
1 package com.hg.s2dao.dao;
2
3 import java.util.List;
4
5 import org.seasar.dao.annotation.tiger.Arguments;
6 import org.seasar.dao.annotation.tiger.Query;
7 import org.seasar.dao.annotation.tiger.S2Dao;
8 import org.seasar.dao.annotation.tiger.Sql;
9
10 import com.hg.s2dao.dto.Example;
11
12 @S2Dao(bean = Example.class)
13 public interface ExampleDao {
14
15 // C
16 /** insert multi */
17 int insertExamples(java.util.List<Example> exps);
18
19 /** insert single */
20 int insertExample(Example exp);
21
22 // R
23 /** search all */
24 List<Example> findAll();
25
26 /** sql command */
27 @Sql("SELECT MAX(E.ID) FROM EXAMPLE E ")
28 String findIDMax();
29
30 /** contains condition */
31 @Query("ID = ? AND NAME = ?")
32 Example findAllByIdAndName(String id, String name);
33
34 /** when multi use or self-define order */
35 @Arguments( { "id1", "id2" })
36 @Query("ID = /*id2*/ OR ID = /*id1*/ ")
37 List<Example> findAllById(String id1, String id2);
38
39 /** list param */
40 @Arguments( { "ids" })
41 @Query("ID IN /*ids*/('') ")
42 List<Example> findAllByIdList(List<String> ids);
43
44 /** param condition */
45 @Arguments( { "ids" })
46 @Query("1 != 0 " //
47 + "/*IF ids != null && ids.size() > 0*/" //
48 + "AND ID IN /*ids*/('') " //
49 + "/*END*/")
50 List<Example> findAllByIdListAdv(List<String> ids);
51
52 // U
53 /** update */
54 int updateExample(Example exp);
55
56 /** object param */
57 @Sql("UPDATE EXAMPLE SET NAME = /*exp.name*/ ")
58 int updateExampleName(Example exp);
59
60 // D
61 /** delete */
62 int deleteExample(Example exp);
63
64 /** delete by param */
65 @Query("ID = ?")
66 int deleteExampleById(String id);
67 }@S2Dao指明了检索对应的数据承接类。
从几个检索函数可以看出，s2dao基本能实现所有种类的检索。
@Query为条件注释(如findAllByIdAndName)，相当于where后面的。
当检索条件的参数需要反复使用或颠倒顺序等的时候(如findAllById)，需要添加@Arguments注释。
@Sql则为原生态无污染的SQL代码注释(如findIDMax)。
可以对输入参数进行条件控制(如findAllByIdListAdv)。

测试程序：
1 private static void testBase() {
2
3 ExampleDao dao = getComponent(ExampleDao.class);
4
5 // C///
6 Example exp = new Example();
7 exp.setId("1");
8 exp.setName("a");
9 System.out.println(dao.insertExample(exp));
10 exp = new Example();
11 exp.setId("2");
12 exp.setName("b");
13 System.out.println(dao.insertExample(exp));
14
15 // R///
16 System.out.println(dao.findAll());
17 System.out.println(dao.findAllByIdAndName("1", "a"));
18 System.out.println(dao.findAllById("1", "2"));
19 System.out.println(dao.findIDMax());
20
21 List<String> ids = new ArrayList<String>();
22 ids.add("1");
23 ids.add("2");
24 System.out.println(dao.findAllByIdList(ids));
25 System.out.println(dao.findAllByIdListAdv(null));
26 System.out.println(dao.findAllByIdListAdv(ids));
27
28 // U///
29 exp = new Example();
30 exp.setId("1");
31 exp.setName("c");
32 System.out.println(dao.updateExample(exp));
33 exp = new Example();
34 exp.setName("haha");
35 System.out.println(dao.updateExampleName(exp));
36
37 // D///
38 exp = new Example();
39 exp.setId("1");
40 exp.setName("a");
41 System.out.println(dao.deleteExample(exp));
42 exp = new Example();
43 exp.setId("2");
44 System.out.println(dao.deleteExample(exp));
45 }
46
47 public static <T> T getComponent(final Class<T> clazz) {
48 final S2Container container = SingletonS2ContainerFactory.getContainer();
49 final Object o = container.getComponent(clazz);
50 final T bean = clazz.cast(o);
51 return bean;
52 }※注：在执行测试前，需要进行框架的初始化，其实就是一行：
SingletonS2ContainerFactory.init();

执行结果当然是OK，控制台LOG就不贴了，贴一下生成的DB LOG，按测试代码中调用dao函数的顺序一一对应：
1 INSERT INTO EXAMPLE (id, name) VALUES ('1', 'a')
2 INSERT INTO EXAMPLE (id, name) VALUES ('2', 'b')
3 SELECT EXAMPLE.id, EXAMPLE.name FROM EXAMPLE
4 SELECT EXAMPLE.id, EXAMPLE.name FROM EXAMPLE WHERE ID = '1' AND NAME = 'a'
5 SELECT EXAMPLE.id, EXAMPLE.name FROM EXAMPLE WHERE ID = '2' OR ID = '1'
6 SELECT MAX(E.ID) FROM EXAMPLE E
7 SELECT EXAMPLE.id, EXAMPLE.name FROM EXAMPLE WHERE ID IN ('1', '2')
8 SELECT EXAMPLE.id, EXAMPLE.name FROM EXAMPLE WHERE 1 != 0
9 SELECT EXAMPLE.id, EXAMPLE.name FROM EXAMPLE WHERE 1 != 0 AND ID IN ('1', '2')
10 UPDATE EXAMPLE SET name = 'c' WHERE id = '1'
11 UPDATE EXAMPLE SET NAME = 'haha'
12 DELETE FROM EXAMPLE WHERE id = '1'
13 DELETE FROM EXAMPLE WHERE id = '2'
2.多表

1 package com.hg.s2dao.dto;
2
3 import org.seasar.dao.annotation.tiger.Bean;
4
5 @Bean(table = "FATHER")
6 public class Father {
7
8 private String id;
9 private String name;
10
11 public String getId() {
12 return id;
13 }
14
15 public void setId(String id) {
16 this.id = id;
17 }
18
19 public String getName() {
20 return name;
21 }
22
23 public void setName(String name) {
24 this.name = name;
25 }
26
27 }
1 package com.hg.s2dao.dto;
2
3 import org.seasar.dao.annotation.tiger.Bean;
4 import org.seasar.dao.annotation.tiger.Relation;
5
6 @Bean(table = "CHILD")
7 public class Child {
8
9 private String id;
10 private String name;
11 private Father father;
12 /* s2dao do not support cascade CUD but only R,so need field 'fId' */
13 private String fId;
14
15 public String getId() {
16 return id;
17 }
18
19 public void setId(String id) {
20 this.id = id;
21 }
22
23 public String getName() {
24 return name;
25 }
26
27 public void setName(String name) {
28 this.name = name;
29 }
30
31 public String getFId() {
32 return fId;
33 }
34
35 public void setFId(String id) {
36 fId = id;
37 }
38
39 @Relation(relationNo = 0, relationKey = "F_ID:ID")
40 public Father getFather() {
41 return father;
42 }
43
44 /* cannot del this method */
45 public void setFather(Father father) {
46 this.father = father;
47 }
48
49 }Father和Child存在一对多/一对一关联，Child中维持着与Father的关系。
看到这你可能会很奇怪，为什么要存在fId字段？不是有Father类了么？遗憾的是，目前s2dao不支持级联的插入更新删除(CUD)，只支持级联检索。fId是为了CUD而存在的。
实现级联检索的是Child.java中的getFather方法，@Relation指明了其关系。relationNo为是第几个外键关联的序号，relationKey为主外键名称声明。

1 package com.hg.s2dao.dao;
2
3 import org.seasar.dao.annotation.tiger.S2Dao;
4
5 import com.hg.s2dao.dto.Father;
6
7 @S2Dao(bean = Father.class)
8 public interface FatherDao {
9
10 /** insert single */
11 int insert(Father f);
12
13 /** delete */
14 int delete(Father c);
15 }
1 package com.hg.s2dao.dao;
2
3 import org.seasar.dao.annotation.tiger.Query;
4 import org.seasar.dao.annotation.tiger.S2Dao;
5
6 import com.hg.s2dao.dto.Child;
7
8 @S2Dao(bean = Child.class)
9 public interface ChildDao {
10
11 /** insert single */
12 int insert(Child c);
13
14 /** contains condition */
15 // cannnot only write: @Query("ID = ?")
16 @Query("CHILD.ID = ?")
17 Child findAllById(String id);
18
19 /** update */
20 int update(Child c);
21
22 /** delete */
23 int delete(Child c);
24
25 }
测试程序：
1 private static void testRelation() {
2
3 FatherDao daoF = getComponent(FatherDao.class);
4 ChildDao daoC = getComponent(ChildDao.class);
5
6 // C///
7 Father popeye = new Father();
8 popeye.setId("1");
9 popeye.setName("Popeye");
10 System.out.println(daoF.insert(popeye));
11
12 Child pipeye = new Child();
13 pipeye.setId("1");
14 pipeye.setName("Pipeye");
15 pipeye.setFId(popeye.getId());
16 System.out.println(daoC.insert(pipeye));
17
18 Child pupeye = new Child();
19 pupeye.setId("2");
20 pupeye.setName("Pupeye");
21 pupeye.setFId(popeye.getId());
22 System.out.println(daoC.insert(pupeye));
23
24 // R///
25 // pipeye.getFather() is null,so need search again
26 Child pipeyeNew = daoC.findAllById(pipeye.getId());
27 System.out.println(pipeyeNew.getFather());
28
29 // U///
30 pipeyeNew.setName("pipeyeNew");
31 System.out.println(daoC.update(pipeyeNew));
32
33 // D///
34 System.out.println(daoC.delete(pipeye));
35 System.out.println(daoC.delete(pupeye));
36 System.out.println(daoF.delete(popeye));
37 }
执行结果DB LOG：
1 INSERT INTO FATHER (id, name) VALUES ('1', 'Popeye')
2 INSERT INTO CHILD (id, f_id, name) VALUES ('1', '1', 'Pipeye')
3 INSERT INTO CHILD (id, f_id, name) VALUES ('2', '1', 'Pupeye')
4 SELECT CHILD.id, CHILD.f_id, CHILD.name, father.id AS id_0, father.name AS name_0 FROM CHILD, FATHER father WHERE CHILD.F_ID = father.ID(+) AND CHILD.ID = '1'
5 UPDATE CHILD SET f_id = '1', name = 'pipeyeNew' WHERE id = '1'
6 DELETE FROM CHILD WHERE id = '1'
7 DELETE FROM CHILD WHERE id = '2'
8 DELETE FROM FATHER WHERE id = '1'


除以上功能，s2dao还可以调用存储过程，这里就不再介绍了。