数据操作

数据操作是srczh.jar框架中业务层最基本的功能。若您还不熟悉业务层功能对象的话,请先了解上章节内容-业务层。

数据操纵三种方式的优缺点

sql方式直观易上手需要编写sql,修改维护困难
SrcJdbc方式不用编写sql
支持视图
输出sql
无法实现复杂关联查询
预sql方式直观、如配置文件般灵活、维护简单。需要编写sql,需要系统启动时加载

insert操作示例

接下来我们针对一张用户表来进行三种不同方式的数据库操作比较

SQL方式新增

1
2
3
4
5
6
7
8
try {
    Object[] pval=new Object[]{map.get("uname"),map.get("passwd"),map.get("tel")};
    Object id=srcDao.insert("insert into src_userinfo(ID,UNAME,PASSWD,TEL)"
            "values(SEQ_USERINFO.NEXTVAL,?,?,?) returning ID into ? ", pval);
    map.put("ID", id);
catch (SQLException e) {
    e.printStackTrace();
}

SrcJdbc方式新增

1
2
3
4
5
6
7
8
9
10
SrcJdbc jdbc=new SrcJdbc();
jdbc.Object="src_userinfo";
jdbc.Return="ID";
jdbc.Where="uname"//新增加上where条件 ,表示重复uname不会插入
try {
    Object id=this.srcDao.insert(jdbc, map);
    map.put("ID", id);
catch (SQLException e) {
    e.printStackTrace();
}

预SQL方式新增

1
2
3
4
5
6
7
8
9
SrcJdbc jdbc=new SrcJdbc();
jdbc.Ysql="user.adduser";
try {
    Object id=this.srcDao.insert(jdbc, map);
    map.put("id", id);
catch (SQLException e) {
    e.printStackTrace();
}
return map;

jdbc.Ysql="user.adduser"; 这句是定义预SQL的地址,sql需要先编写在xml文件中,并且在配置文件中配置预sql路径jdbc.sql=srcsql

sql定义

user.xml文件内容如下

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
<?xml encoding="UTF-8"?>  
<database>
    <sql id="getuser">
        select * from src_userinfo where id=? and  state=?
    </sql>
     
    <sql id="deleuser">
        delete from src_userinfo where id=?
    </sql>
     
    <sql id="adduser">
        insert into src_userinfo(id,uname,passwd,tel)values(SEQ_USERINFO.NEXTVAL,?,?,?) returning ID into ? 
    </sql>
     
    <sql id="updateuser">
        update  src_userinfo set uname=?,passwd=?,tel=? where id=?
    </sql>
</database>

delete操作示例

SQL方式删除

1
2
3
4
5
6
7
8
String sql="delete from src_userinfo where id=? ";
int n=0
try {
    n=this.srcDao.delete(sql, new Object[] {map.get("id")});
catch (SQLException e1) {
    e1.printStackTrace();
}
return n;

SrcJdbc方式删除

1
2
3
4
5
6
7
8
9
SrcJdbc jdbc=new SrcJdbc();
jdbc.Object="src_userinfo";  //将要访问的表名
jdbc.Where="id";   
int n=0;
try {
    n=this.srcDao.delete(jdbc, map);
catch (SQLException e) {
    e.printStackTrace();
}

预SQL方式删除

该方式只需要把sql语句按下面的名称定义到user.xml中即可

1
2
3
4
5
6
7
8
SrcJdbc jdbc=new SrcJdbc();
jdbc.Ysql="user.deleuser";  //预SQL路径
int n=0;
try {
    n=this.srcDao.delete(jdbc, map);
catch (SQLException e) {
    e.printStackTrace();
}

update操作示例

SQL方式修改

1
2
3
4
5
6
7
8
String sql="update  src_userinfo set uname=?,passwd=?,tel=? where id=?";
int n=0;
try {
    n=this.srcDao.update(sql, new Object[] {map.get("uname"),map.get("passwd"),map.get("tel"),map.get("id")});
catch (SQLException e1) {
    e1.printStackTrace();
}
return n;

SrcJdbc方式修改

1
2
3
4
5
6
7
8
9
10
11
SrcJdbc jdbc=new SrcJdbc();
jdbc.Object="src_userinfo";    //将要访问的表名
jdbc.Set="uname,passwd,tel";     //需要修改的字段
jdbc.Where="id";                //过滤的条件字段
int n=0;
try {
    n=this.srcDao.update(jdbc, map);
catch (SQLException e) {
    e.printStackTrace();
}
return n;

预SQL方式修改

1
2
3
4
5
6
7
8
9
SrcJdbc jdbc=new SrcJdbc();
jdbc.Ysql="user.updateuser";
int n=0;
try {
    n=this.srcDao.update(jdbc, map);
catch (SQLException e) {
    e.printStackTrace();
}
return n;

select操作示例

SQL方式查询

1
2
3
4
5
6
7
8
String sql="select * from src_userinfo where id=? and state=?";
Map rmap = new HashMap();
try {
    rmap = this.srcDao.get(sql, new Object[] {map.get("id"),map.get("state")});
catch (SQLException e) {
    e.printStackTrace();
}
return rmap;

SrcJdbc方式查询

1
2
3
4
5
6
7
8
9
10
SrcJdbc jdbc=new SrcJdbc();
jdbc.Object="src_userinfo";       //将要访问的表名
jdbc.Where="id,state";                 //将要匹配查询的字段
Map rmap=null;
try {
    rmap=this.srcDao.get(jdbc,map);
catch (SQLException e) {
    e.printStackTrace();
}
return rmap;

预SQL方式查询

1
2
3
4
5
6
7
8
9
SrcJdbc jdbc=new SrcJdbc();
jdbc.Ysql="user.getuser";
Map rmap=null;
try {
    rmap=this.srcDao.get(jdbc,map);
catch (SQLException e) {
    e.printStackTrace();
}
return rmap;

批量操作

进行批量的新增

1
2
3
4
5
6
7
8
@Override
public int pinsert(List list) {
    SrcJdbc jdbc= new SrcJdbc();
    jdbc.Object="src_userinfo";
     
    int n=this.srcDao.insert(jdbc, list);
    return n;
}

控制器调用以及List中的数据如下

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
/**调用批量新增*/
public void pinsert() {
    List list=new ArrayList();
    Map map=new HashMap();
    map.put("uname""admin");
    map.put("tel""133138138");
     
    Map map2=new HashMap();
    map2.put("uname""zhoujun");
    map2.put("tel""133138139");
    list.add(map);
    list.add(map2);
     
    int n=ldao.pinsert(list);
    this.write(n+"");
}

进行批量修改

1
2
3
4
5
6
7
8
9
10
@Override
public int pupdate(List list) {
    SrcJdbc jdbc= new SrcJdbc();
    jdbc.Object="src_userinfo";
    jdbc.Set="tel";
    jdbc.Where="uname";
     
    int n=this.srcDao.update(jdbc, list);
    return n;
}

控制器中批量修改方法把List中的把用户的电话号码批量修改,前面加0

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
    /**调用批量修改*/
    public void pupdate() {
        List list=new ArrayList();
        Map map=new HashMap();
        map.put("uname""admin");
        map.put("tel""0133138138");
         
        Map map2=new HashMap();
        map2.put("uname""zhoujun");
        map2.put("tel""0133138139");
        list.add(map);
        list.add(map2);
         
        int n=ldao.pupdate(list);
        this.write(n+"");
    }

修改中如果使用ID做where条件,则需要在map中put"id"这个值

事务

使用事务通常是用于多个业务的关联性、原子性,好比转完账一定要扣除原账数目,保证数据的一致性

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
/**
     * 执行事务操作,同时修改两个用户的积分一个增5,一个减5
     */
    public int trans(int jf){
        int is=0;
        List<SrcJdbc> ls =new ArrayList<SrcJdbc>();
        Map map=new HashMap();
        map.put("id"111);
        //第一个用户增加积分
        SrcJdbc sjdbc = new SrcJdbc();
        sjdbc.Object="src_userinfo";
        sjdbc.DDL=sjdbc.UPDATE;
        sjdbc.Set="JIFEN=JIFEN+"+jf;
        sjdbc.Where="id";
        sjdbc.setMap(map);
        ls.add(sjdbc);
         
        //第二个用户减少积分
        Map map2=new HashMap();
        map2.put("id"11);
        SrcJdbc ujdbc = new SrcJdbc();
        ujdbc.Object="src_userinfo";
        ujdbc.DDL=ujdbc.UPDATE;
        ujdbc.Set="JIFEN=JIFEN-"+jf;
        ujdbc.Where="id";
        ujdbc.setMap(map2);
        ls.add(ujdbc); 
         
        String[] ns=this.BatchSrcJdbc(ls);
        return ns.length;
    }

通常一个事务中是写表操作,允许是多个新增或修改删除等,也可以混合形式,如其中一个操作不成功,全体回滚。

事务执行jdbc同样适用于使用预sql方式

存储过程

调用存储过程一般分有两个分别为输入输出参数或单一的情况

1
2
3
4
5
6
7
8
9
/**使用存储过程**/
@Override
public Map pcall(Map map) {
    Map rmap=new HashMap();
    Object[] data= (Object[]) map.get("data");
    Object[] out= (Object[]) map.get("out");
    rmap=this.srcDao.call("call finduser(?,?)",data, out);
    return rmap;
}

示例代码中有两个map做为输入输出参数,里面的存放着object对象数组。

1
2
3
4
5
6
7
8
9
10
11
12
create or replace procedure finduser(usname IN  varchar2, num OUT varchar2) is
 
v_count number;
v_uname varchar2(20);
 
begin
  v_uname:=usname;
   
  select count(1) into v_count from src_userinfo t where uname like '%'||v_uname||'%';
 
num :=v_count;
end finduser;

上面存储过程中只是简单的通过输入参数模糊查询字段UNAME包含输入字符的总数,然后通过输出参数返回到java中

1
2
3
4
5
6
7
8
9
10
11
12
/**调用存储过程
 *  查询名字包含jun的有多少位用户,返回值在num中
 * */
public void pcall() {
 
    Map map=new HashMap();
    map.put("data",new Object[] {"jun"});
    map.put("out",new Object[] {"num"});
     
    Map rmap=ldao.pcall(map);
    this.write(rmap.get("num")+"");
}

分别有多项输入输出参数请使用Object对象定义然后通过map传入,若无输出参数的过程只需把out参数设置为null

请您对本章评分:
2016 - 2021 © srczh.com 版权所有 增值电信经营许可:粤ICP备19068081号
深圳市中文远星科技有限公司