JAVA开发之简化Dao层、提高开发效率（二）

最新推荐文章于 2024-10-10 09:56:47 发布
最新推荐文章于 2024-10-10 09:56:47 发布
阅读量133 收藏
点赞数
文章标签： java 数据库
原文链接：https://juejin.im/post/5a4c72ba6fb9a0450f22532e
版权

上一篇文章给大家介绍了基本的Dao封装和领域模型与SQL语句对应的方式。本节介绍一下如何使领域模型与SQL对应。
我们先理一下思路：

  1. SQL语句与领域模型对应时需要哪些信息
  2. JDBC的结果集ResultSet如何自动封装到对应的领域模型
  3. 运用反射解析出来的领域模型信息有个上下文，方便用的时候去取，防止反复解析领域模型
  4. 领域模型中有些字段是通过表连接获取的外表字段，但是insert语句的时候又不需要这些字段，仅仅是封装ResultSet的时候才需要，如何避免
  5. 假定我们的开发规范是根据领域模型字段的驼峰命名规则生成对应的下划线数据库表字段--这样可以在数据库中通用，如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结果集。


转载于:https://juejin.im/post/5a4c72ba6fb9a0450f22532e

weixin_34313182
关注
JAVA开发之简化Dao层、提高开发效率
weixin_34013044的博客
01-02 269
通常我们在开发Java企业级应用的时候使用的技术大部分是Spring、Hibernate、mybatis、Struts2等。尤其是Spring，相信这个庞大而优雅的技术体系你已经离不开了，在我们项目代码中基本是骨干力量的存在。而我们使用的ORM框架大多数也是Hibernate、mybatis或者Spring提供的jdbc简单封装的JdbcTemplate。如果我们的项目组开发人员对所选型的ORM框...
java 开发效率_JAVA开发之简化Dao层、提高开发效率（三）
weixin_39589253的博客
02-24 123
上一篇文章为大家介绍了如何使用反射解析领域模型的属性信息并缓存，本节将介绍如何自动封装JDBC的结果集ResultSet到实体对象中，这里正好使用到缓存的领域模型。我们先理一下思路：怎样正确的调用如rs.getString("name")、rs.getLong("size")得到想要的数据，这些数据如何正确的调用实体的set方法设值，这里rs中获取的值必须是实体中属性的类型。PreparedSta...
Form-encoded method must contain at least one @Field.
liunian823的博客
05-12 9147
使用Retrofit框架，加载POST请求方式接口时，出现Form-encoded method must contain at least one @Field.的问题。 原因是，该请求方式没有请求参数，而在注解部分使用了 @FormUrlEncoded，去掉该注解即可...
Field 'id' doesn't have a default value
weixin_34391445的博客
03-28 108
Spring项目中设置主键的时候通过 @Id@GeneratedValue(strategy = GenerationType.IDENTITY) 则在建表的时候， 主键应该要设置自增，否则的话，就会报这个错误. 转载于:https://www.cnblogs.com/Grace-is-enough/p/10615997.html...
base-framework是对常用的java web开发封装实用功能来提高开发效率
01-28
【标题】"base-framework"是一个专为Java Web开发设计的框架，它的主要目的是为了提升开发效率，通过将常见的开发任务进行封装，使开发者能够更快速、更高效地完成项目构建。这个框架集成了多种实用功能，旨在简化...
FastQuery 基于Java语言.他的使命是:简化Java操作数据层
07-06
他的使命是:简化Java操作数据层.提供少许Annotation,消费者只用关心注解的含义,这就使得框架的核心便于重构,便于持续良性发展.,仅仅只需要设计编写DAO接口即可,在项目初始化阶段采用ASM生成好实现类. 因此,开发代码...
java使用mybits自动生成实体和dao层的工具.rar
04-16
针对这一问题，"java使用mybits自动生成实体和dao层的工具" 提供了解决方案，它可以帮助开发者通过配置快速生成所需的代码，极大地提高了开发效率。 MyBatis Generator（MBG）是MyBatis官方提供的一个代码生成工具...
完整版 Java开发实训课程系列-MyBatis框架技术 02.MyBatis核心配置与DAO开发（共34页）.pptx
12-26
`typeAliases`元素用于为常见的Java类型或自定义类型定义别名，使得在`parameterType`和`resultType`中可以使用简写，提高开发效率。 **5. 类型处理器** `typeHandlers`定义了Java类型与JDBC类型的对应关系，...
制造业MES源码.rar_MES java_MES源码_java开发制造业_mes java源码_制造
07-15
4. **丰富的开源框架**：Spring、MyBatis等Java开源框架简化了开发工作，提高了开发效率。 在“制造业MES源码”中，我们可以看到实际的实现细节，例如： 1. **数据访问层（DAO）**：使用Java的JDBC或ORM框架（如...
bugfree升级报错“Field 'id' doesn't have a default value”问题解决
云天空的博客
11-19 543
MySQL 5中，出现错误提示： Field 'id' doesn't have a default value 解决方法： 打开my.ini，查找 sql-mode="STRICT_TRANS_TABLES,NO_AUTO_CREATE_USER,NO_ENGINE_SUBSTITUTION" 修改为 sql-mode="NO_AUTO_CREATE_USER,NO_
Spring ReflectionUtils 使用记录
ZG123456h的博客
12-23 1298
System.out.println("---------- findMethod ----------"); // 获取方法 Method method1 = ReflectionUtils.findMethod(DemoObject.class, "method01"); Method method2 = ReflectionUtils.findMethod(DemoObject.class, "method02"); System.out.println(method1); System.out.p.
Java Web性能优化之一：减少DAO层的调用次数
小灯光环
11-14 3213
关于java web中service多次调用dao层与数据库内部处理逻辑的性能对比
SpringBoot--Easycode、mybatisX插件生成entity,controller,service,dao,mapper IDEA版 项目提效神器
wnrun的博客
04-20 4685
直接对数据的表生成entity,controller,service,dao,mapper,无需任何编码，简单而强大。
web工程中DAO层CRUD的简化操作
成长的脚印
06-28 778
在ssh框架中,在dao层一些简单重复的操作一般都要让接口的实现类去继承HibernateDaoSupport这个类,然后去做相应的CRUD操作,这样就会使代码看起来很臃肿.例如下面的代码:package ssh.DAO; import org.springframework.orm.hibernate5.support.HibernateDaoSupport; import ssh.doma...
JDBC学习总结4-------简化DAO的写法
weixin_33701617的博客
07-10 77
1.com.hanchao.util包是工具类； packagecom.hanchao.util;importjava.sql.Connection;importjava.sql.DriverManager;importjava.sql.PreparedStatement;importjava.sql.ResultSet;importja...
【JAVA开源】基于Vue和SpringBoot的高校学科竞赛平台
最新发布
杨荧的CSDN博客
10-10 974
教师功能有个人中心，题目类型管理，竞赛题库管理，竞赛类型管理，竞赛信息管理，报名信息管理，竞赛评分管理，参赛名单管理，晋级名单管理，获奖名单管理，竞赛总结管理，报销清单管理，成绩申诉管理，参赛信息管理，参赛信息管理，往年成绩管理，获奖情况管理。
C语言 | 第十章 | 函数 作用域
ZJC744575的博客
10-05 1257
为完成某一功能的程序指令(语句)的集合,称为函数。在C语言中,函数分为:自定义函数、系统函数(查看C语言函数手册)函数还有其它叫法，比如方法等，在本视频课程中，我们统一称为 函数。返回类型 函数名（形参列表）{执行语句...;// 函数体return 返回值;// 可选形参列表：表示函数的输入函数中的语句：表示为了实现某一功能代码块函数可以有返回值,也可以没有, 如果没有返回值，返回类型 声明为 void。
Hibernate入门：解决DAO层繁琐代码与提高开发效率
Hibernate是Java领域中一种广泛使用的对象关系映射（Object-Relational Mapping, ORM）框架，它允许开发者将Java对象持久化到关系数据库中，简化了数据访问层（Data Access Object, DAO）的编码工作。本章节将深入...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值