手写持久层框架------无需写sql语句即可完成对单表的CRUD操作。

已于 2024-07-12 11:22:56 修改
阅读量689 收藏 9
点赞数 9
分类专栏： Java高阶 文章标签： sql 数据库
于 2024-07-10 10:32:01 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_72156649/article/details/140315150
版权

目的：巩固知识点

  1. 技术栈：java+mysql+反射+自定义注解+泛型+jdbc
  2. 持久层框架：与数据库交互的一层成为持久层。完成orm操作
  3. o(Object对象)  r:(relative关系)   m:(mapping映射)。实体类---数据库表    属性---表的字段   实体类对象---- 一条记录   集合----表中多条记录
  4. 手撕持久层框架：自己编写持久层和框架，可以完成无需写sql语句即可完成对单表的CRUD操作。

1.1创建一个maven的java工程 

 1.2 引入依赖的jar

<dependency>
      <groupId>mysql</groupId>
      <artifactId>mysql-connector-java</artifactId>
      <version>8.0.28</version>
    </dependency>
    <dependency>
      <groupId>com.alibaba</groupId>
      <artifactId>druid</artifactId>
      <version>1.1.10</version>
    </dependency>

1.3 创建数据源的属性文件 

driverClassName=com.mysql.cj.jdbc.Driver
url=jdbc:mysql://localhost:3306/数据库名?serverTimezone=Asia/Shanghai
username=账号
password=密码

 1.4  创建DbUtil工具类

package com.syh.util;

import com.alibaba.druid.pool.DruidDataSourceFactory;

import javax.sql.DataSource;
import javax.xml.crypto.Data;
import java.io.InputStream;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.util.Properties;

public class Dbutil {
    private static final DataSource dataSource;
//    private static String driverClassName;
//    private static String url;
//    private static String username;
//    private static String password;
    static {
        try {
            //该类用于读取属性文件
            Properties properties = new Properties();
            //加载属性文件
            InputStream inputStream = ClassLoader.getSystemResourceAsStream("db.properties");
            properties.load(inputStream);
            dataSource = DruidDataSourceFactory.createDataSource(properties);
        }
        catch (Exception e) {
            throw new RuntimeException("无法读取db.properties");
        }
    }
    //获取连接数据库对象:思考:如果我们把驱动名和url和密码硬编码放在配置文件中,那么我们就不需要在代码中写死这些内容了,只需要在配置文件中读取即可
    public static Connection getConnection() {
        try {
            return dataSource.getConnection();
        }
        catch (Exception e) {
            throw new RuntimeException("1111");
        }
    }

    public static void closeAll(Connection connection, PreparedStatement ps,ResultSet rs) {
        try {
            if (rs != null) {
                rs.close();
            }
            if (ps != null) {
                ps.close();
            }
            if (connection != null) {
                connection.close();
            }
        }
        catch (Exception e) {
            throw new RuntimeException("无法关闭数据库连接");
        }
    }
}

1.5 定义注解

//属性的注解
@Target(ElementType.FIELD)
//运行时执行
@Retention(RetentionPolicy.RUNTIME)
public @interface TableField {
    String name();
}


//主键的注解
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
public @interface TableFieldKey {
    String value() default "id";
}


//表名的注解
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface TableName {
    String value();
}

1.6  单表的添加

public class BaseDao<T> {
    private Class<T> clazz;

    public BaseDao() {
        //this表示子类的dao对象
        Class<? extends BaseDao> aClass = this.getClass();
        //获取当前子类的父类的的反射类
        ParameterizedType genericSuperclass = (ParameterizedType) aClass.getGenericSuperclass();

        //获取反射类中的泛型类型
        Type actualTypeArgument = genericSuperclass.getActualTypeArguments()[0];
        clazz = (Class) actualTypeArgument;
    }

    //添加功能
    public int insert(T t) {
        StringBuilder sql = new StringBuilder("insert into ");
        //根据对象获取该对象的反射类Class
        Class<?> aClass = t.getClass();
        //获取反射类上的注解对象
        TableName annotation = aClass.getAnnotation(TableName.class);
        //表名
        String tableName = "";
        if (annotation != null) {
            //获取注解的属性
            tableName = annotation.value();
        } else {
            //获取实体名
            tableName = aClass.getSimpleName();
        }
        sql.append(tableName);
        //获取所有列名
        Field[] fields = aClass.getDeclaredFields();
        ArrayList<String> columns = new ArrayList<String>();
        //获取所有值
        ArrayList<Object> values = new ArrayList<Object>();
        for (Field field : fields) {
            TableField tableField = field.getAnnotation(TableField.class);
            TableFieldKey tableFieldKey = field.getAnnotation(TableFieldKey.class);
            String name = "";
            if (tableFieldKey != null) {
                continue;
            }
            if (tableField != null) {
                name = tableField.name();
            } else {
                name = field.getName();
            }
            Object v = null;
            field.setAccessible(true);
            try {
                v = field.get(t);
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            }
            values.add("'" + v + "'");
            columns.add(name);
        }


        String columName = columns.toString().replace("[", "(").replace("]", ")");
        String valueNames = values.toString().replace("[", "(").replace("]", ")");
        sql.append(columName);
        sql.append(" values ");
        sql.append(valueNames);
        System.out.println(sql);

        int i = 0;

        try {
            Connection connection = Dbutil.getConnection();
            PreparedStatement preparedStatement = connection.prepareStatement(sql.toString());
            i = preparedStatement.executeUpdate();
        } catch (SQLException e) {
            e.printStackTrace();
        }

        return i;
    }
}

1.7  单表的修改

public int update(T t) {
        StringBuffer sql = new StringBuffer("update ");
        //获取表名
        Class<?> aClass = t.getClass();
        String tableName = aClass.getSimpleName();
        TableName annotation = aClass.getAnnotation(TableName.class);
        if (annotation != null) {
            //获取注解的表名
            tableName = annotation.value();
        }
        sql.append(tableName + " set ");
        String where = " where ";
        //获取所有列对象
        Field[] fields = aClass.getDeclaredFields();
        for (Field field : fields) {
            //获取属性名
            String name = field.getName();
            TableField tableField = field.getAnnotation(TableField.class);
            // 尝试获取字段上的TableFieldKay注解，用于后续判断是否需要拼接SQL的where条件
            //获取主键
            TableFieldKey tableFieldKey = field.getAnnotation(TableFieldKey.class);
            // 设置字段可访问，以突破访问权限限制，获取字段值
            field.setAccessible(true);
            Object value = null;
            try {
                // 尝试获取字段的值
                value = field.get(t);
            } catch (IllegalAccessException e) {
                // 当访问字段失败时，打印异常堆栈跟踪，但并未对异常进行进一步处理
                e.printStackTrace();
            }
            // 如果字段上存在TableFieldKay注解，则拼接SQL的where条件
            if (tableFieldKey != null) {
                // 从注解中获取字段在数据库表中的名称
                String tableFieldKayName = tableFieldKey.value();
                // 拼接where条件，此处应注意SQL注入的风险
                where += tableFieldKayName + "='" + value + "'";
                continue;
            }
            if (tableField != null) {
                //获取注解的属性名
                name = tableField.name();
            }
            sql.append(name + "='" + value + "',");
        }
        try {

            sql.deleteCharAt(sql.length() - 1).append(where);
            System.out.println(sql);
            Connection connection = Dbutil.getConnection();
            PreparedStatement preparedStatement = connection.prepareStatement(sql.toString());
            int i = preparedStatement.executeUpdate();
            return i;
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return 0;
    }

1.8 单表的删除

//删除
    public int delete(Object id) {
        StringBuffer sql = new StringBuffer("delete from ");
        //获取表名
        String tableName = clazz.getSimpleName();
        //获取注解的表名
        TableName annotation = clazz.getAnnotation(TableName.class);
        if (annotation != null) {
            tableName = annotation.value();
        }
        sql.append(tableName + " where ");
        Field[] fields = clazz.getDeclaredFields();
        for (Field field : fields) {
            //获取where条件注解
            TableFieldKey tableField = field.getAnnotation(TableFieldKey.class);
            //允许获得私有属性的值
            field.setAccessible(true);
            if (tableField != null) {
                String tableFieldKay = tableField.value();
                sql.append(tableFieldKay + "='" + id + "'");
            }
        }
        try {
            System.out.println(sql);
            Connection conn = Dbutil.getConnection();
            PreparedStatement ps = conn.prepareStatement(sql.toString());
            int i = ps.executeUpdate();
            return i;
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return 0;
    }

 1.9  根据id查询

public T selectById(Object id) {
        StringBuffer sql = new StringBuffer("select * from ");
        //获取表名
        String tableName = clazz.getSimpleName();
        TableName annotation = clazz.getAnnotation(TableName.class);
        if (annotation != null) {
            tableName = annotation.value();
        }
        sql.append(tableName + " where ");
        Field[] fields = clazz.getDeclaredFields();
        for (Field field : fields) {
            TableFieldKey tableField = field.getAnnotation(TableFieldKey.class);
            if (tableField != null) {
                String tableFieldKay = tableField.value();
                sql.append(tableFieldKay + "='" + id + "'");
            }
        }
        System.out.println(sql);
        Connection conn = Dbutil.getConnection();
        PreparedStatement ps = null;
        try {
            ps = conn.prepareStatement(sql.toString());
            ResultSet rs = ps.executeQuery();
            while (rs.next()) {
                T t = clazz.newInstance();
                for (Field field : fields) {
                    field.setAccessible(true);
                    TableField tableField = field.getAnnotation(TableField.class);
                    TableFieldKey tableId = field.getAnnotation(TableFieldKey.class);
                    //获取属性名
                    String name = field.getName();
                    if (tableField != null) {
                        name = tableField.name();
                    }
                    if (tableId != null) {
                        name = tableId.value();
                    }
                    Object object = rs.getObject(name);
                    field.set(t, object);
                }
                System.out.println(t);
                return t;
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

 1.10  查询所有

public List<T> selectAll() {
        List<T> list=new ArrayList<>();
        StringBuilder sql = new StringBuilder("select * from ");
        //获取表名
        String tableName = clazz.getSimpleName();
        TableName annotation = clazz.getAnnotation(TableName.class);
        if (annotation != null) {
            tableName = annotation.value();
        }
        sql.append(tableName);
        Connection conn = Dbutil.getConnection();
        try {
            PreparedStatement ps = conn.prepareStatement(sql.toString());
            ResultSet rs = ps.executeQuery();

            Field[] fields = clazz.getDeclaredFields();
            while (rs.next()) {
                T t = clazz.newInstance();
                for (Field field : fields) {
                    field.setAccessible(true);
                    TableField tableField = field.getAnnotation(TableField.class);
                    TableFieldKey tableId = field.getAnnotation(TableFieldKey.class);
                    String name = field.getName();
                    if (tableField != null) {
                        name = tableField.name();
                    }
                    if (tableId != null) {
                        name = tableId.value();
                    }
                    Object object = rs.getObject(name);
                    field.set(t, object);
                }
                list.add(t);
            }
            System.out.println(list);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return list;
    }

 2. 测试

可以进行相关测试，自己测试

 

白七不七
关注
专栏目录
不需要写Sql语句的Mybatis工具：Tkmybatis
weixin_42531204的博客
02-29 1918
Tkmybatis是基于Mybatis框架开发的一个工具，通过调用它提供的方法实现对单表的数据操作，不需要写任何sql语句，这极大地提高了项目开发效率。 1：Tkmybatis使用 pom.xml添加依赖 <dependency> <groupId>tk.mybatis</groupId> <artifactId>mapper-spr...
Sqlbean“无SQL”编程框架，可自动生成SQL语句，减少90%的SQL语句编写，可媲美MybatisPlus
onlywei77的博客
09-26 1150
Sqlbean是一款通过Java语法编写SQL语句并自动生成的ORM插件，除了支持Mybatis也同时支持Spring Jdbc，内置大量常用方法，无需编写DAO层，能减少90%的SQL语句，帮助你快速进行业务功能开发。
java sqllite持久化_(柯昌合)Android Sqlite 持久化框架。类似于hibernate的sqlite框架。不用写SQL语句，操作数据库 | 学步园...
weixin_35613582的博客
03-02 213
package com.cng.utils;import java.sql.SQLException;import android.content.Context;import android.database.sqlite.SQLiteDatabase;import android.util.Log;import com.cng.modal.Hello;import com.j256.ormli...
什么是CRUD？ CRUD的操作
热门推荐
DJyzh的博客
08-11 16万+
版权声明：转载请附上文章地址https://blog.csdn.net/qq_42672839 什么是CRUD？ CRUD的操作 CRUD是指在做计算处理时的增加(Create)、读取查询(Retrieve)、更新(Update)和删除(Delete)几个单词的首字母简写。主要被用在描述软件系统中DataBase或者持久层的基本操作功能。 数据库CRUD操作 一、删除表 dr...
Hibernate简单讲解
weixin_42694511的博客
06-16 4574
所谓的ORM就是利用描述对象和数据库表之间映射的元数据，自动把java应用程序中的对象持久化到关系型数据库的表中。通过操作java对象，就可以完成对数据库表的操作。可以把ORM理解为关系型数据和对象的一个纽带，开发人员只需关注纽带一段映射的对象即可。Hibernate框架使用ORM思想对数据库进行crud操作在web阶段学习的javabean，更准确的叫法应该是实体类ORM：Object Relational Mapping，对象关系映射。让实体类和数据库表对应，让实体类属性和表中字段对应。
Mybatis框架详细介绍
一切如你的博客
12-06 9221
Mybatis框架详细介绍(入门够用了)
结合mybatis-plus实现简单不需要写sql的多表查询
08-25
MyBatis-Plus 是一个基于 MyBatis 的简化版本，它提供了一系列的便捷功能，包括自动 CRUD 操作、条件构造器等，使得开发者无需编写大量的 SQL 语句。在多表查询方面，MyBatis-Plus 提供了简单易用的方法，让开发者...
免费开源-jOOQ 是用 Java 编写 SQL 的最佳方式
11-08
jOOQ 是一个内部 DSL 和源代码生成器，将 SQL 语言建模为类型安全的 Java API，以帮助您编写更好的 SQL。 其主要特点包括： 源代码生成器 用于类型安全查询构造和动态 SQL的 DSL API 次要特征包括： DAO 数据导出...
Mybatis-Plus BaseMapper的用法详解
09-07
这些方法已经考虑了SQL的编写，开发者无需手动编写SQL语句，只需传入对应的实体对象即可。例如，对于`Student`实体，可以这样使用`BaseMapper`： ```java public interface StudentMapper extends BaseMapper...
基于Java的持久层框架，零配置，零SQL操作持久层.zip
最新发布
03-23
Java持久层框架是Java开发中用于数据库操作的关键技术，它为开发者提供了抽象化的数据库访问机制，使得开发者可以避免直接编写繁琐的SQL语句，提高开发效率。本资料包"基于Java的持久层框架，零配置，零SQL操作持久...
dotnet-FreeSql是一个功能强大的NETStandard库用于对象关系映射程序ORM
08-14
通过使用FreeSql，开发者可以轻松地实现对数据库的CRUD（创建、读取、更新和删除）操作，以及更复杂的查询和事务管理。 FreeSql的亮点之一是其强大的表达式树解析能力。它可以解析C#表达式，将其转化为相应的SQL...
单链表之CRUD操作
程序彤的博客
09-09 196
package 链表.单链表crud; public class SingleLinkedListDemo { public static void main(String[] args) { SingleLinkedList sll = new SingleLinkedList(); HeroNode heroNode1 = new HeroNode(1, "虚空掠夺者"); HeroNode heroNode2 = new HeroNode(2,
不想写sql？试试这款轻量级JAVA ORM框架!
Github导航站
03-02 1534
  大家好，我是为广大程序员兄弟操碎了心的小编，每天推荐一个小工具/源码，装满你的收藏夹，每天分享一个小技巧，让你轻松节省开发效率，实现不加班不熬夜不掉头发，是我的目标！   今天小编推荐一款Java ORM框架——Bee，Bee 是一个简单，易用，功能强大，开发速度快，编码少的 JAVA ORM 框架。   Bee开发速度快、简单、自动高效且具有人工智能(AI)特性！它的编码复杂度是O(1)，不管操作多少张表，都可以不需要写额外的Dao代码。Bee同时支持面向对象和自定义SQL两种方式，简单场景和复杂场景
spring boot(五)：spring data jpa的使用
weixin_33781606的博客
09-21 1486
在上篇文章springboot(二)：web综合开发中简单介绍了一下spring data jpa的基础性使用，这篇文章将更加全面的介绍spring data jpa 常见用法以及注意事项 使用spring data jpa 开发时，发现国内对spring boot jpa全面介绍的文章比较少案例也比较零碎，因此写文章总结一下。本人也正在翻译Spring Data JPA 参考指南,有兴趣的同学欢...
iOS sqllite封装,不用写SQL语句才是封装的目的.
11-15 347
#import &lt;Foundation/Foundation.h&gt; NS_ASSUME_NONNULL_BEGIN @class SQTool; @class Cloumn; typedef enum : NSUInteger { Typeinteger, Typetext, Typereal, } Type; typedef void(^Creat...
通用mapper在什么情况下不用写sql语句
程序哈哈的博客
03-06 1519
多表没有 没有实体类映射的表也没有 只有单表的增删改查
MyBatis-Plus快速入门：简化持久层开发与CRUD操作
它封装了基础的数据库操作，如插入(new)、查询(find)、更新(update)和删除(delete)记录，无需程序员手动编写SQL语句，只需调用对应的接口方法即可。这极大地减少了样板代码，提高了开发效率。 **常用注解**是...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值