JDBC持久化组件

业务需求

业务在面临持久化问题时，经常会遇到对不同数据源的匹配问题。在解决这一问题时，采用多套适配代码是一种常用手段，但是这种解决方式对开发影响较大，需要更多持久化工作，此外在持久化开发过程中还需要有一些常用的数据库建库建表操作，都需要平台的持久化组件统一屏蔽这类问题。

解决方案

iuap平台采用iuap-jdbc作为数据持久化组件，实现对业务数据的持久化服务。该组件对JDBC做了轻量封装，采用基于注解的ORM映射机制，使用简单，简化了代码配置，通过少量代码就可以完成持久化操作。组件能够自动适配多种数据源，提供不同数据库的基本语法转换能力，做到一套语法，多种数据库兼容执行，所有这些都对开发透明，开发者可以更关注于业务本身，屏蔽了底层数据库切换带来的影响。

功能说明

1. 封装JDBC，基于注解的ORM映射机制，简化代码配置；
2. 面向对象编程，直接操作POJO，少量代码完成增删改查操作；
3. 自动识别适配数据源，提供多种数据库的语法转换，目前支持MySQL、Oracle和PostgreSQL;

功能特征

• 多数据库语法适配

目前组件适配了mysql,oracle和postgresql的通用语法。

• 数据源

多数据库持久化组件使用CrossdbDataSource装饰外部数据源，应用的数据源可以自由配置，组件在完成数据源的适配的同时，为多数据库的语法适配能力做铺垫。

• 自动分页

组件提供分页API，应用只需要传入查询条件sql，不必关心分页逻辑，组件自动帮您完成分页。

• 主子表组合保存，修改

组件提供主子表组合操作。

使用说明

Maven依赖

<dependency>
  <groupId>com.yonyou.iuap</groupId>
  <artifactId>iuap-jdbc</artifactId>
  <version>${iuap.modules.version}</version>
</dependency>

${iuap.modules.version} 为平台在maven私服上发布的组件的version。

相关配置

简单示例

使用iuap-jdbc完成单表的增删改查。示例包括实体类、DAO类、Service类。其中dao类通过注入BaseDao类，并使用它对数据进行操作。

数据库表

• user数据库表

    drop table if exists users;
  
    create table users (
      id char(36),
      name varchar(20),
      ts datetime,
      dr int
    );
  

spring配置文件

• 在Spring中声明数据源和BaseDAO

    <!-- 通用配置文件加载 -->
    <context:property-placeholder system-properties-mode="OVERRIDE" ignore-unresolvable="true" location="classpath*:/application.properties"/>

    <!-- 数据源配置, 使用Tomcat JDBC连接池 -->
    <bean id="jdbcDataSource" class="org.apache.tomcat.jdbc.pool.DataSource" destroy-method="close">
        <!-- Connection Info -->
        <property name="driverClassName" value="${jdbc.driver}"/>
        <property name="url" value="${jdbc.url}"/>
        <property name="username" value="${jdbc.username}"/>
        <property name="password" value="${jdbc.password}"/>
        <property name="defaultCatalog" value="${jdbc.catalog}"/>

        <!-- Connection Pooling Info -->
        <property name="maxActive" value="${jdbc.pool.maxActive}"/>
        <property name="maxIdle" value="${jdbc.pool.maxIdle}"/>
        <property name="minIdle" value="0"/>
        <property name="maxWait" value="${jdbc.pool.maxWait}"/>
        <property name="defaultAutoCommit" value="true"/>

        <property name="minEvictableIdleTimeMillis" value="${jdbc.pool.minEvictableIdleTimeMillis}"/>
        <property name="removeAbandoned" value="${jdbc.pool.removeAbandoned}"/>
        <property name="removeAbandonedTimeout" value="${jdbc.pool.removeAbandonedTimeout}"/>
    </bean>

    <!-- iuap跨数据库数据库装饰类 -->
    <bean id="crossDBDataSource" class="com.yonyou.iuap.persistence.bs.framework.ds.CrossdbDataSource">
        <constructor-arg name="dataSource" ref="jdbcDataSource"/>
    </bean>

    <!-- spring 事务配置 -->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="crossDBDataSource"/>
    </bean>

    <!-- 使用annotation定义事务 -->
    <tx:annotation-driven transaction-manager="transactionManager" proxy-target-class="true"/>

    <!-- 声明spring-jdbcTemplate -->
    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
        <property name="dataSource" ref="crossDBDataSource"></property>
    </bean>

    <!-- 声明BaseDAO -->
    <bean id="baseDAO" class="com.yonyou.iuap.persistence.bs.dao.BaseDAO">
        <property name="jdbcTemplate" ref="jdbcTemplate"/>
        <property name="dbMetaHelper" ref="dbMetaInfo"/>
    </bean>

    <!-- 声明数据源辅助类 -->
    <bean id="dbMetaInfo" class="com.yonyou.iuap.persistence.bs.util.DBMetaHelper">
        <property name="jdbcTemplate" ref="jdbcTemplate"/>
    </bean>

实体类

• 生成User.java对象

       @Entity(name = "User",namespace="your.package.name")
    @Table(name = "users")
    public class User extends BaseEntity{
  
        @Id
        @Column(name = "id")
        @GeneratedValue(strategy = Stragegy.UUID, moudle = "users")
        private String id;
  
        @Column(name = "name")
        private String name;
  
        @Column(name="ts")
        private Date ts;
  
        @Column(name="dr")
        private Integer dr;
  
        //省略getter,setter...
  
        public String getMetaDefinedName() {
            return "User";
        }
  
        public String getNamespace() {
            return "your.package.name";
        }
    }
  

注意:

实体类需要继承com.yonyou.iuap.persistence.vo.BaseEntity类。

@Id，@coloumn等注解是iuap-jdbc中的注解，请开发者注意和javax包下的注解进行区分，不要混淆。 @GeneratedValue(strategy = Stragegy.UUID, moudle = "users")注解中的ID生成策略可以参考Stragegy中的枚举值，和iuap-oid中的生成策略保持一致。

getMetaDefinedName和getNamespace方法是为了后期的元数据操作时候预留，如果不需要元数据，开发人员手动重写即可（必须有该方法）。

业务代码中不需要操作操作User对象的ts属性，但是每次修改操作ts属性都会变成服务器的当前时间。组件的sql增强功能会自动在增加或修改的时候，在sql上增加ts字段，使得应用更加专注于业务相关的逻辑。

DAO类

• 推荐新建一个实体类User的DAO

    @Repository
    public class UserDao {
  
        //BaseDAO是iuap-jdbc的基础dao类，该类中包含了一些通用的数据库操作
        @Autowired
           private BaseDAO dao;
  
        public User queryByID(String id) throws DAOException {
            return dao.queryByPK(User.class, id);
        }
  
        public void save(User user) throws DAOException {
            dao.insert(user);
        }
  
        public void remove(User user) throws DAOException {
            dao.remove(user);
        }
  
        public void remove(List<User> users) throws DAOException {
            dao.remove(users);
        }
  
        public String update(User user) throws DAOException {
            return dao.update(user);
        }
  

        public Page queryPage(String name,PageRequest pageRequest) throws     DAOException {
               SQLParameter parameter = new SQLParameter();
               parameter.addParam(name+"%");
               Page<User> page =dao.queryPage("select * from users " + "where name like ?", parameter, pageRequest, User.class);
               return page;
        }
    }

组件提供分页API，应用只需要传入查询条件sql，不必关心分页逻辑，组件自动帮您完成分页。详见BaseDAO的API queryPage()

Service类

• 创建实体类User的Service

    @Service
    public class UserService {

        @Autowired
        private UserDao userDao;

        @Transactional(rollbackFor = DAOException.class)
        public String save(User user) throws DAOException {
            return userDao.save(user);
        }

        @Transactional(rollbackFor = DAOException.class)
        public String update(User user) throws DAOException {
            return userDao.update(user);
        }

        @Transactional(rollbackFor = DAOException.class)
        public String remove(String id) throws DAOException {
            User user = new User();
            user.setId(id);
            return userDao.remove(user);
        }

        public String queryById(String id) throws DAOException {
            return userDao.queryByPK(User.class,id);
        }

         public Page queryPage(String name,PageRequest pageRequest) throws DAOException {
            return userDao.queryPage(name,pageRequest);
           }
    }

主子表示例

主表实体

@Entity
@Table(name = "iuap_parent")
public class Parent extends BaseEntity{

    private static final long serialVersionUID = -4725617307982134263L;

    @Id
    @Column(name = "id")
    private String id;

    @Column(name = "id")
    private String name;    

    @Column(name = "ts")
    private java.util.Date ts;      

    public String getId() {
        return id;
    }
    public void setId(String id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public Date getTs() {
        return ts;
    }
    public void setTs(Date ts) {
        this.ts = ts;
    }

    @Override
    public String getMetaDefinedName() {
        return "iuap_parent";
    }

       @Override
    public String getNamespace() {
        return "iuap_parent";
    }

}

子表实体

@Entity
@Table(name = "iuap_child")
public class Child extends BaseEntity{

    /**
     * 
     */
    private static final long serialVersionUID = -6415805183878684588L;

    @Id
    @Column(name = "id")
    private String id;

    //通过外键注解与主表建立关联referenceTableName为主表表名，referencedColumnName为主表主键
    @FK(referenceTableName="iuap_parent",referencedColumnName="id", name = "")  
    @Column(name = "parentid")
    private String parentid;

    @Column(name = "name")
    private String name;    

    @Column(name = "ts")
    private java.util.Date ts;

    public String getId() {
        return id;
    }

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

    public String getParentid() {
        return parentid;
    }

    public void setParentid(String parentid) {
        this.parentid = parentid;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public java.util.Date getTs() {
        return ts;
    }

    public void setTs(java.util.Date ts) {
        this.ts = ts;
    }

    @Override
    public String getMetaDefinedName() {
        return "iuap_child";
    }

    @Override
    public String getNamespace() {
        return "iuap_child";
    }
}

主子联合实体

public class CombineVO {

    private Parent parent;

    private List<Child> childs;

    public Parent getParent() {
        return parent;
    }

    public void setParent(Parent order) {
        this.parent = order;
    }

    public List<Child> getChilds() {
        return childs;
    }

    public void setChilds(List<Child> childs) {
        this.childs = childs;
    }



}

主表dao

public class ParentDao {

    @Autowired
    private BaseDAO dao;


    public Parent queryByPK(String pk) throws DAOException {

        return dao.queryByPK(Parent.class, pk);
    }

    public Page<Parent> queryPage(Map<String, Object> searchParams, PageRequest pageRequest) throws DAOException {
        StringBuffer sqlBuffer = new StringBuffer("select * from iuap_parent where 1=1 ");
        SQLParameter sqlParameter = new SQLParameter();
        buildSql(searchParams, sqlBuffer, sqlParameter);
        String sql = sqlBuffer.toString();
        return dao.queryPage(sql, sqlParameter, pageRequest, Parent.class);
    }

    public void save(Parent vo) throws DAOException {
        dao.save(vo);
    }

    public void save(Parent vo, Child[] details) throws DAOException {
        dao.save(vo, details);
    }

    public void remove(Parent vo) throws DAOException {
        dao.remove(vo);
    }

    public void remove(List<Parent> vos) throws DAOException {
        dao.remove(vos);
    }

    //业务开发根据自己的需求，修改查询条件的拼接方式
    private void buildSql(Map<String, Object> searchParams, StringBuffer sqlBuffer, SQLParameter sqlParameter) {

        int index = 0;
        StringBuffer sb = new StringBuffer();
        for (Map.Entry<String, Object> entry : searchParams.entrySet()) {
            String[] keySplit = entry.getKey().split("__");//xzn
            if (keySplit.length == 2) {
                String columnName = keySplit[1];
                String compartor = keySplit[0];
                Object value = entry.getValue();
                if (value != null && StringUtils.isNotBlank(value.toString())) {

                    sb.append(columnName).append(" ").append(compartor).append(" ? ");
                    // 处理模糊查询
                    value = "like".equalsIgnoreCase(compartor) ? value + "%" : value;
                    sqlParameter.addParam(value);
                    index ++;

                    if(index != searchParams.keySet().size()){
                        sb.append(" or ");
                    }
                }
            }
        }

        String conditionSql = sb.toString();
        if(StringUtils.isNoneBlank(conditionSql)){
            sqlBuffer.append(" and (" + conditionSql.toString() + ");");
        }

    }

}

子表dao

public class ChildDao {
    @Autowired
    private BaseDAO dao;

    public Child queryByPK(String pk) throws DAOException {
        return dao.queryByPK(Child.class, pk);
    }

    public List<Child> queryChildByParentId(String parentId) throws DAOException {
        String sql = "select * from iuap_child where parentid = ? ";
        SQLParameter sqlParameter = new SQLParameter();
        sqlParameter.addParam(parentId);
        return dao.queryByClause(Child.class, sql,sqlParameter);
     }

    public void save(Child vo) throws DAOException {
        dao.save(vo);
    }
    public void update(List<Child>  vo) throws DAOException {
        dao.updateOptional(vo);
    }

    public void remove(Child vo) throws DAOException {
        dao.remove(vo);
    }

    public void remove(List<Child> vos) throws DAOException {
        dao.remove(vos);
    }

    //业务开发根据自己的需求，修改查询条件的拼接方式
    private void buildSql(Map<String, Object> searchParams, StringBuffer sqlBuffer, SQLParameter sqlParameter) {

        int index = 0;
        StringBuffer sb = new StringBuffer();
        for (Map.Entry<String, Object> entry : searchParams.entrySet()) {
            String[] keySplit = entry.getKey().split("__");//xzn
            if (keySplit.length == 2) {
                String columnName = keySplit[1];
                String compartor = keySplit[0];
                Object value = entry.getValue();
                if (value != null && StringUtils.isNotBlank(value.toString())) {

                    sb.append(columnName).append(" ").append(compartor).append(" ? ");
                    // 处理模糊查询
                    value = "like".equalsIgnoreCase(compartor) ? value + "%" : value;
                    sqlParameter.addParam(value);
                    index ++;

                    if(index != searchParams.keySet().size()){
                        sb.append(" or ");
                    }
                }
            }
        }

        String conditionSql = sb.toString();
        if(StringUtils.isNoneBlank(conditionSql)){
            sqlBuffer.append(" and (" + conditionSql.toString() + ");");
        }

    }

}

主表service

@Service
public class ParentService {

    @Autowired
    private ParentDao dao;

    @Autowired
    private ChildDao childDao;


    public Parent getTestorderById(String id) throws DAOException {
        return dao.queryByPK(id);
    }

    @Transactional
    public void deleteById(String id) throws DAOException {
        Parent parent = new Parent();
        parent.setId(id);
        dao.remove(parent);
    }

    @Transactional
    public void batchDelete(List<String> ids) throws DAOException {
        List<Parent> deleteVos = new ArrayList<Parent>();
        for (int i = 0; i < ids.size(); i++) {
            Parent parent = new Parent();
            parent.setId(ids.get(i));
            deleteVos.add(parent);
        }
        if (deleteVos.size() > 0) {
            dao.remove(deleteVos);
        }
    }

    @Transactional
    public Parent saveEntity(Parent entity) throws DAOException {
        dao.save(entity);
        return entity;
    }

    @Transactional
    public void saveAll(CombineVO vo) throws DAOException {
        Parent parent = vo.getParent();
        if(parent.getId()!=null){
            parent.setStatus(VOStatus.UPDATED);
        } else {
            parent.setStatus(VOStatus.NEW);
        }

        List<Child> childs = vo.getChilds();
        for (int i = 0; i < childs.size(); i++) {
            Child Child = childs.get(i);
            if(StringUtils.isBlank(Child.getId())){
                Child.setStatus(VOStatus.NEW);
            } else {
                Child.setStatus(VOStatus.UPDATED);
            }
        }
        Child[] children = childs.toArray(new Child[0]);

        dao.save(parent, children);
    }

    public Page<Parent> getPage(Map<String, Object> searchParams, PageRequest pageRequest) throws DAOException {
        return dao.queryPage(searchParams, pageRequest);
    }


}

子表service

@Service
public class ChildService {

    @Autowired
    private ChildDao dao;

    public Child getTestorderDetailById(String id) throws DAOException {
        return dao.queryByPK(id);
    }

    @Transactional
    public void deleteById(String id) throws DAOException {
        Child child = new Child();
        child.setId(id);
        dao.remove(child);
    }

    @Transactional
    public void batchDelete(List<String> ids) throws DAOException {
        List<Child> deleteVos = new ArrayList<Child>();
        for (int i = 0; i < ids.size(); i++) {
            Child child = new Child();
            child.setId(ids.get(i));
            deleteVos.add(child);
        }
        if (deleteVos.size() > 0) {
            dao.remove(deleteVos);
        }
    }

    @Transactional
    public Child saveEntity(Child entity) throws DAOException {
        dao.save(entity);
        return entity;
    }

    public List<Child> queryListByParentId(String parentId) throws DAOException {
        return dao.queryChildByParentId(parentId);
    }

}

组件提供主子表组合操作。API对应BaseDAO的save(),入参为一主多子。 注意 使用这个方法的时候，Entity的status属性必须设置。

status说明如下：

iuap-jdbc相关API

• BaseDAO

其他相关说明

查询结果解析器

组件提供了多种查询结果解析器。解析器类名以及说明如下：

函数转换对应表

• mysql

• oracle

• postgresql

更多详细的使用方法，请参考示例工程(DevTool/examples/example-iuap-jdbc)