JAVA開發之簡化Dao層、提高開發效率（二）

草原上的格林發表於2019-03-01

上一篇文章給大家介紹了基本的Dao封裝和領域模型與SQL語句對應的方式。本節介紹一下如何使領域模型與SQL對應。
我們先理一下思路：

SQL語句與領域模型對應時需要哪些資訊
JDBC的結果集ResultSet如何自動封裝到對應的領域模型
運用反射解析出來的領域模型資訊有個上下文，方便用的時候去取，防止反覆解析領域模型
領域模型中有些欄位是通過表連線獲取的外表欄位，但是insert語句的時候又不需要這些欄位，僅僅是封裝ResultSet的時候才需要，如何避免
假定我們的開發規範是根據領域模型欄位的駝峰命名規則生成對應的下劃線資料庫表欄位–這樣可以在資料庫中通用，如name生成NAME_、userName生成USER_NAME_

需要的領域模型資訊如下：

package com.applet.sql.record;

import java.lang.reflect.Method;

/**
 * 結果集返回表結構
 * Created by Jackie Liu on 2017/8/20.
 */
public class TableColumn {

    private String fieldName;
    private String columnName;
    private Class<?> javaType;
    private Method fieldGetMethod;
    private Method fieldSetMethod;
    private boolean isTransient = false;
    private boolean isPrimaryKey = false;
    private ExtendType extendType;

    public String getFieldName() {
        return fieldName;
    }

    public void setFieldName(String fieldName) {
        this.fieldName = fieldName;
    }

    public String getColumnName() {
        return columnName;
    }

    public void setColumnName(String columnName) {
        this.columnName = columnName;
    }

    public Class<?> getJavaType() {
        return javaType;
    }

    public void setJavaType(Class<?> javaType) {
        this.javaType = javaType;
    }

    public Method getFieldGetMethod() {
        return fieldGetMethod;
    }

    public void setFieldGetMethod(Method fieldGetMethod) {
        this.fieldGetMethod = fieldGetMethod;
    }

    public Method getFieldSetMethod() {
        return fieldSetMethod;
    }

    public void setFieldSetMethod(Method fieldSetMethod) {
        this.fieldSetMethod = fieldSetMethod;
    }

    public boolean isTransient() {
        return isTransient;
    }

    public void setTransient(boolean aTransient) {
        isTransient = aTransient;
    }

    public boolean isPrimaryKey() {
        return isPrimaryKey;
    }

    public void setPrimaryKey(boolean primaryKey) {
        isPrimaryKey = primaryKey;
    }

    public ExtendType getExtendType() {
        return extendType;
    }

    public void setExtendType(ExtendType extendType) {
        this.extendType = extendType;
    }

    public String getPlaceholder() {
        if (extendType != null) {
            return extendType.getPlaceholder();
        }
        return "?";
    }

    @Override
    public String toString() {
        final StringBuilder sb = new StringBuilder("TableColumn{");
        sb.append("fieldName=`").append(fieldName).append(```);
        sb.append(", columnName=`").append(columnName).append(```);
        sb.append(", javaType=").append(javaType);
        sb.append(", fieldGetMethod=").append(fieldGetMethod);
        sb.append(", fieldSetMethod=").append(fieldSetMethod);
        sb.append(", isTransient=").append(isTransient);
        sb.append(", isPrimaryKey=").append(isPrimaryKey);
        sb.append(", extendType=").append(extendType);
        sb.append(`}`);
        return sb.toString();
    }
}
複製程式碼

領域模型資訊的解析如下：

package com.applet.sql.record;

import com.applet.sql.parse.BeanNameConverter;
import org.apache.commons.lang3.StringUtils;
import org.apache.commons.lang3.reflect.FieldUtils;
import org.springframework.util.Assert;
import org.springframework.util.ReflectionUtils;

import javax.persistence.*;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * Created by Jackie Liu on 2017/6/28.
 */
public class DomainModelAnalysis {

    private Class<?> clazz;
    //資料庫名稱
    private String tableName;
    //主鍵名稱
    private String primaryKey;
    //預設的資料庫欄位拼接字串，例如：_NAME, _NAME2, _NAME3
    private String defaultColumnArrayStr;
    //欄位集合
    private List<TableColumn> tableColumnList = new ArrayList<TableColumn>();

    /**
     * 獲取實體類的資訊
     */
    public void analysisBean() {
        Assert.notNull(clazz);
        Entity entity = clazz.getAnnotation(Entity.class);
        if (entity == null) {
            return;
        }

        //獲取資料庫表名稱
        Table table = clazz.getAnnotation(Table.class);
        Assert.notNull(table, String.format("[%s] @Table is null", clazz.getName()));
        Assert.notNull(table.name(), String.format("[%s] the value of @Table`s name  is null", clazz.getName()));

        tableName = table.name();

        ReflectionUtils.clearCache();
        //Method[] methods = ReflectionUtils.getAllDeclaredMethods(clazz);
        Field[] fields = FieldUtils.getAllFields(clazz);
        for (Field field : fields) {
            if (field.getAnnotations().length <= 0) {
                continue;
            }
            TableColumn tableColumn = new TableColumn();
            tableColumn.setFieldName(field.getName());
            tableColumn.setJavaType(field.getType());

            String setMethodName = "set" + StringUtils.capitalize(field.getName());
            Method setMethod = ReflectionUtils.findMethod(clazz, setMethodName, field.getType());
            Assert.notNull(setMethod, String.format("[%s] : file name [%s] does not has set method. Expect method : %s", clazz.getName(), field.getName(), setMethodName));
            tableColumn.setFieldSetMethod(setMethod);

            String getMethodName = "get" + StringUtils.capitalize(field.getName());
            Method getMethod = ReflectionUtils.findMethod(clazz, getMethodName);
            Assert.notNull(getMethod, String.format("[%s] : file name [%s] does not has get method. Expect method : %s", clazz.getName(), field.getName(), getMethodName));
            tableColumn.setFieldGetMethod(getMethod);

            Id key = field.getAnnotation(Id.class);
            Column column = field.getAnnotation(Column.class);
            ColumnExtend columnExtend = field.getAnnotation(ColumnExtend.class);
            Transient transientAn = field.getAnnotation(Transient.class);
            TransientField transientField = field.getAnnotation(TransientField.class);

            if (column != null) {
                if (StringUtils.isBlank(column.name())) {
                    tableColumn.setColumnName(BeanNameConverter.camelToUnderline(field.getName()));
                } else {
                    tableColumn.setColumnName(column.name().toUpperCase());
                }
            }
            if (columnExtend != null) {
                tableColumn.setExtendType(columnExtend.extendType());
            }
            if (transientField != null) {
                if (StringUtils.isBlank(transientField.name())) {
                    tableColumn.setColumnName(BeanNameConverter.camelToUnderline(field.getName()));
                } else {
                    tableColumn.setColumnName(transientField.name().toUpperCase());
                }
                tableColumn.setTransient(true);
            }
            if (transientAn != null) {
                tableColumn.setColumnName(BeanNameConverter.camelToUnderline(field.getName()));
                tableColumn.setTransient(true);
            }

            if (key != null) {
                Assert.notNull(column, String.format("[%s] : file name [%s] has @Id, but does not has @Column", clazz.getName(), field.getName()));
                primaryKey = tableColumn.getColumnName();
                tableColumn.setPrimaryKey(true);
            }

            Assert.notNull(tableColumn.getColumnName(), String.format("[%s] : file name [%s] does not has column name (see @Column with name value or @TransientField with name value)", clazz.getName(), field.getName()));
            tableColumnList.add(tableColumn);
        }
        defaultColumnArrayStr = joinColumn(", ");
    }

    /**
     * 拼裝資料庫欄位，split為分隔符
     *
     * @param split 分隔符
     * @return 如：_NAME1, _NAME2, _NAME3
     */
    public String joinColumn(String split) {
        StringBuilder stringBuilder = new StringBuilder();
        int index = 0;
        for (int i = 0, size = tableColumnList.size(); i < size; i++) {
            TableColumn tableColumn = tableColumnList.get(i);
            if (tableColumn.isTransient()) {
                continue;
            }
            if (index == 0) {
                stringBuilder.append(tableColumn.getColumnName());
                index++;
                continue;
            }
            stringBuilder.append(split).append(tableColumn.getColumnName());
        }
        return stringBuilder.length() > 0 ? stringBuilder.toString() : null;
    }

    /**
     * 拼裝資料庫欄位，split為分隔符
     *
     * @param split 分隔符
     * @return 如：{"_NAME1, _NAME2, _NAME3", "?, ?, ?"}
     */
    public String[] joinColumnWithPlaceholder(String split) {
        StringBuilder stringBuilder = new StringBuilder();
        StringBuilder phBuilder = new StringBuilder();
        int index = 0;
        for (int i = 0, size = tableColumnList.size(); i < size; i++) {
            TableColumn tableColumn = tableColumnList.get(i);
            if (tableColumn.isTransient()) {
                continue;
            }
            if (index == 0) {
                stringBuilder.append(tableColumn.getColumnName());
                phBuilder.append(tableColumn.getPlaceholder());
                index++;
                continue;
            }
            stringBuilder.append(split).append(tableColumn.getColumnName());
            phBuilder.append(split).append(tableColumn.getPlaceholder());
        }
        return stringBuilder.length() > 0 ? new String[]{stringBuilder.toString(), phBuilder.toString()} : null;
    }

    public List<TableColumn> getTableColumnList() {
        return tableColumnList;
    }

    public Class<?> getClazz() {
        return clazz;
    }

    public void setClazz(Class clazz) {
        this.clazz = clazz;
    }

    public String getDefaultColumnArrayStr() {
        return defaultColumnArrayStr;
    }

    public String getTableName() {
        return tableName;
    }

    public String getPrimaryKey() {
        return primaryKey;
    }

    /**
     * 獲取tableColumn物件
     *
     * @param columnName 資料庫列名
     * @return
     */
    public TableColumn getTableColumnByColumnName(String columnName) {
        if (StringUtils.isEmpty(columnName)) {
            return null;
        }
        for (TableColumn tableColumn : tableColumnList) {
            if (tableColumn.getColumnName().equals(columnName)) {
                return tableColumn;
            }
        }
        return null;
    }

    /**
     * 獲取tableColumn物件
     *
     * @param fieldName java屬性名
     * @return
     */
    public TableColumn getTableColumnByFieldName(String fieldName) {
        if (StringUtils.isEmpty(fieldName)) {
            return null;
        }
        for (TableColumn tableColumn : tableColumnList) {
            if (tableColumn.getFieldName().equals(fieldName)) {
                return tableColumn;
            }
        }
        return null;
    }

    @Override
    public String toString() {
        if (StringUtils.isBlank(tableName)) {
            return "[" + clazz.getName() + "] is not domain class.";
        }
        final StringBuilder sb = new StringBuilder("DomainModelAnalysis{");
        sb.append("clazz=").append(clazz.getName());
        sb.append(", tableName=`").append(tableName).append(```);
        sb.append(", primaryKey=`").append(primaryKey).append(```);
        sb.append(", defaultColumnArrayStr=`").append(defaultColumnArrayStr).append(```);
        sb.append(", tableColumnList=").append(tableColumnList);
        sb.append(`}`);
        return sb.toString();
    }
}
複製程式碼

l領域模型快取的上下文如下：

package com.applet.sql.record;

import com.applet.bean.PackageScanner;
import com.applet.sql.type.TypeHandlerRegistry;
import org.apache.commons.lang3.StringUtils;
import org.apache.log4j.Logger;
import org.springframework.beans.factory.InitializingBean;

import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;

/**
 * CommonModelContext class
 *
 * @author Jackie Liu
 * @date 2017/10/17
 */
public class DomainModelContext implements InitializingBean {

    protected static final Logger log = Logger.getLogger(DomainModelContext.class);

    /**
     * 擴充套件的領域模型完整類名
     */
    private Set<String> extendClassSet;
    /**
     * 掃描包，讀取包下所有的實體類並快取符合條件的領域模型資訊，多個包用英文逗號分隔
     */
    private String scanPackages;
    /**
     * 領域模型解析集合
     */
    private Map<Class<?>, DomainModelAnalysis> modelMap = new HashMap<Class<?>, DomainModelAnalysis>();
    /**
     * 資料庫欄位轉換器
     */
    private static final TypeHandlerRegistry typeHandlerRegistry = new TypeHandlerRegistry();

    public DomainModelContext() {

    }

    public DomainModelAnalysis getDomainModelAnalysis(Class<?> clazz) {
        DomainModelAnalysis domainModelAnalysis = modelMap.get(clazz);
        if (domainModelAnalysis == null) {
            domainModelAnalysis = registerBean(clazz);
        }
        return domainModelAnalysis;
    }

    public void addDomainModelAnalysis(DomainModelAnalysis domainModelAnalysis) {
        modelMap.put(domainModelAnalysis.getClazz(), domainModelAnalysis);
    }

    public Set<String> getExtendClassSet() {
        return extendClassSet;
    }

    public void setExtendClassSet(Set<String> extendClassSet) {
        this.extendClassSet = extendClassSet;
    }

    public String getScanPackages() {
        return scanPackages;
    }

    public void setScanPackages(String scanPackages) {
        this.scanPackages = scanPackages;
    }

    public static TypeHandlerRegistry getTypeHandlerRegistry() {
        return typeHandlerRegistry;
    }

    public DomainModelAnalysis registerBean(Class<?> clazz) {
        synchronized (modelMap) {
            DomainModelAnalysis domainModelAnalysis = new DomainModelAnalysis();
            domainModelAnalysis.setClazz(clazz);
            domainModelAnalysis.analysisBean();
            if (log.isDebugEnabled()) {
                log.debug(domainModelAnalysis);
            }
            modelMap.put(clazz, domainModelAnalysis);
            return domainModelAnalysis;
        }
    }

    @Override
    public void afterPropertiesSet() throws Exception {
        if (extendClassSet == null) {
            extendClassSet = new HashSet<String>();
        }
        if (StringUtils.isNotBlank(scanPackages)) {
            Set<String> list = PackageScanner.findPackageClass(scanPackages);
            if (list.size() > 0) {
                extendClassSet.addAll(list);
            }
        }
        for (String className : extendClassSet) {
            Class<?> clazz = Class.forName(className);
            registerBean(clazz);
        }
    }
}
複製程式碼

DomainModelContext支援通過配置實體bean和掃描包的方式解析領域模型，具體在spring.xml中配置方式如下：

<!-- 領域模型上下文 -->
 <bean id="domainModelContext" class="com.applet.sql.record.DomainModelContext">
        <property name="extendClassSet">
            <set>
                <value>com.jackiee.business.model.Report</value>
            </set>
        </property>
        <property name="scanPackages" value="com.jackie"/>
 </bean>
複製程式碼

領域模型解析完成之後，就可以通過DomainModelContext獲取實體資訊了，如：

@Override
 public <T> int insert(T t) {
        DomainModelContext domainModelContext = SpringContextHelper.getBean(DomainModelContext.class);
        DomainModelAnalysis domainModelAnalysis = domainModelContext.getDomainModelAnalysis(t.getClass());
        List<TableColumn> tableColumnList = domainModelAnalysis.getTableColumnList();
        List<Object> list = new ArrayList<Object>();
        for (int i = 0, size = tableColumnList.size(); i < size; i++) {
            TableColumn tableColumn = tableColumnList.get(i);
            if (tableColumn.isTransient()) {
                continue;
            }
            Object value = ReflectionUtils.invokeMethod(tableColumn.getFieldGetMethod(), t);
            ExtendType extendType = tableColumn.getExtendType();
            if (extendType != null && extendType.getCode() != ExtendType.DEFAULT.getCode()) {
                value = value.toString();
            }
            list.add(value);
        }

        String[] array = domainModelAnalysis.joinColumnWithPlaceholder(", ");
        String sql = String.format("INSERT INTO %s (%s) VALUES (%s)", domainModelAnalysis.getTableName(), array[0], array[1]);
        return getJdbcTemplate().update(sql, list.toArray(new Object[0]));
 }
複製程式碼

有了這些有用的資訊之後，下一篇將為大家介紹如何自動封裝ResultSet結果集。

JAVA開發之簡化Dao層、提高開發效率
2019-02-27
Java
JAVA開發之簡化Dao層、提高開發效率（三）
2018-01-04
Java
使用 RelProxy 提高 Java 開發效率
2015-10-31
Java
iOS 提高開發效率
2018-02-07
iOS
用 FutureBuilder 提高開發效率
2019-07-02
Rebuild
提高開發效率小技巧
2021-01-28
從開發框架提高開發效率說起
2017-11-20
框架
如何提高App開發的效率？
2021-11-24
APP
提高開發效率之VS Code基礎配置篇
2019-02-16
API開發平臺，提高API開發及管理效率
2021-11-09
API
提高iOS App開發效率的方法
2024-01-12
iOSAPP
iOS開發經驗談：如何提高應用開發效率？
2013-07-31
iOS
Facebook工程師開發工具提高VR內容開發效率
2017-08-08
工程師VR
CoffeeScript和Sass提高Web開發效率
2021-09-09
Web
提高iOS開發效率的方法和工具
2015-08-14
iOS
如何大幅度提高 Mac 開發效率
2016-05-29
Mac
提高企業開發效率的優質工具：快速開發平臺
2020-03-01
Android開發必看-快速提高 Android 開發效率的 Web 工具
2016-02-17
AndroidWeb
Delphi提高開發效率之GExperts專家的使用說明
2024-08-15
.NET開發中合理使用物件對映庫，簡化和提高工作效率
2023-12-25
物件
【譯】提高React開發效率的5個工具
2018-10-23
React
提高 Linux 開發效率的 5 個工具
2015-12-15
Linux
快速提高Android開發效率的Web工具
2015-09-12
AndroidWeb
如何能提高CSS編寫技巧提高Web前端開發效率
2019-09-25
CSSWeb前端
移動開發時批處理壓縮圖片提高開發效率
2021-07-05
移動開發
開發效率提升之工具篇
2017-05-03
mybatis入門基礎(二)----原始dao的開發和mapper代理開發
2015-06-28
MyBatisAPP
本地開發、兩層開發、三層開發與分散式開發
2010-03-25
分散式
六，Spring Boot 容器中 Lombok 外掛的詳細使用，簡化配置，提高開發效率
2024-09-02
Spring BootLombok
使用Java和Google Guava簡化開發
2024-07-20
JavaGoGuava
簡訊貓二次開發(java版)
2018-09-14
Java
華為雲 DAS，大幅提高資料庫開發效率
2019-02-21
資料庫
一些提高開發效率的小體會
2019-04-22
提高開發效率的 Eclipse 實用操作（2）
2016-09-30
Eclipse
提高python開發效率的10個小技巧
2016-08-29
Python
提高Android開發效率的9個Web工具
2015-07-22
AndroidWeb
模組化開發(二)
2019-05-19
元件化開發（二）
2018-04-23
元件化

JAVA開發之簡化Dao層、提高開發效率（二）

需要的領域模型資訊如下：

領域模型資訊的解析如下：

l領域模型快取的上下文如下：

相關文章