手撕ORM框架

已于 2022-07-18 10:04:12 修改
阅读量182 收藏 1
点赞数
文章标签： java mysql
于 2022-07-15 09:51:13 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_58212960/article/details/125797165
版权

ORM:(Object relative Mapping)对象关系映射框架。帮你自动把数据库中的记录和java实体类对应映射在一起。

框架对应的包

 

annotation包:

        TableName:

package com.lqh.annotation;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Target(value = {ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
public @interface TableName {
    String value();
}

        TableField:

package com.lqh.annotation;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Target(value = ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
public @interface TableField {
    String value();
}

dao包:

        StudentDao:

package com.lqh.dao;

import com.lqh.entity.Student;
import com.lqh.utils.BaseDao;

/**
 * @Author Li Qinghua
 * @Create 2022/7/14 20:30
 */
public class StudentDao extends BaseDao<Student> {
}

entity包:

        Student:

package com.lqh.entity;

import com.lqh.annotation.TableName;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

/**
 * @Author Li Qinghua
 * @Create 2022/7/14 20:17
 */
@Data
@AllArgsConstructor
@NoArgsConstructor
@TableName(value = "tb_student")
public class Student {
    private Integer id;
    private String name;
    private Integer age;
    private String address;
}

utils包:

        BaseDao:

package com.lqh.utils;

import com.lqh.annotation.TableField;
import com.lqh.annotation.TableId;
import com.lqh.annotation.TableName;

import java.lang.reflect.Field;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

/**
 * @Author Li Qinghua
 * @Create 2022/7/14 20:14
 */
public class BaseDao<E> {

    private Connection connection;
    private ResultSet res;
    private PreparedStatement ps;

    private Class<?> clazz;

    public BaseDao(){

        //this对应的是子类对象，获取当前类的反射类对象
        Class<? extends BaseDao> aClass = this.getClass();

        //获取当前反射类的父类反射类--包含父类的泛型
        ParameterizedType genericSuperclass = (ParameterizedType) aClass.getGenericSuperclass();

        //获取泛型的反射类
        Type[] actualTypeArguments = genericSuperclass.getActualTypeArguments();

        //System.out.println("~~~~~~~~~~");
        //System.out.println(Arrays.toString(actualTypeArguments));
        clazz= (Class<?>) actualTypeArguments[0];
        //System.out.println(clazz.getSimpleName());

    }



    public int insert(E e){
        try {
            StringBuffer sql = new StringBuffer("insert into ");

            //获取表名
            Class<?> aClass = e.getClass();

            TableName tableNameAnnotation = aClass.getAnnotation(TableName.class);
            String tableName = "";

            //是否存在该注解
            if (tableNameAnnotation != null) {
                tableName = tableNameAnnotation.value();
            } else {
                tableName = aClass.getSimpleName();
            }
            sql.append(tableName);

            //获取反射类对象中所有的属性对象
            Field[] declaredFields = aClass.getDeclaredFields();

            //创建两个集合、分别存放列和列的值
            List<String> columns = new ArrayList<>();
            List<String> values = new ArrayList<>();

            for (Field field : declaredFields) {
                field.setAccessible(true);
                TableField tableField = field.getAnnotation(TableField.class);
                if (tableField != null) {
                    columns.add(tableField.value());
                } else {
                    columns.add(field.getName());
                }

                values.add("'" + field.get(e) + "'");
            }

            sql.append(columns.toString().replace("[", "(").replace("]", ")"));
            sql.append(" values ");
            sql.append(values.toString().replace("[", "(").replace("]", ")"));


            System.out.println(sql);
            connection=DBUtil.getConn();
            ps=connection.prepareStatement(sql.toString());
            int i = ps.executeUpdate();
            return 1;
        }catch (Exception o){
            o.printStackTrace();
        }finally {
            DBUtil.closeAll(res,ps,connection);
        }
        return 0;
    }

    public int delete(Object id){
        StringBuffer sql=new StringBuffer("delete from ");
        try {
            TableName tableName = clazz.getAnnotation(TableName.class);
            if (tableName != null) {
                sql.append(tableName.value() + " where ");
            } else {
                sql.append(clazz.getSimpleName() + " where ");
            }
            Field[] declaredFields = clazz.getDeclaredFields();
            boolean flag = false;
            for (Field field : declaredFields) {
                field.setAccessible(true);
                TableId tableId = field.getAnnotation(TableId.class);
                if (tableId != null) {
                    flag = true;
                    sql.append(tableId.value() + "='" + id + "'");
                    break;
                }
            }

            if (flag == false) {
                throw new RuntimeException("没有添加主键注解！");
            }


            //System.out.println(sql);
            connection = DBUtil.getConn();
            ps = connection.prepareStatement(sql.toString());
            int i = ps.executeUpdate();
            return i;
        }catch (Exception o){
            o.printStackTrace();
        }finally {
            DBUtil.closeAll(res,ps,connection);
        }
        return 1;
    }

    public int update(E e){
        try{
            StringBuffer sql=new StringBuffer("update ");

            Class<?> eClass = e.getClass();

            TableName tableName = eClass.getAnnotation(TableName.class);
            if(tableName!=null){
                sql.append(tableName.value()+" set ");
            }else{
                sql.append(eClass.getSimpleName()+" set ");
            }


            String where=" where ";

            boolean flag=false;
            Field[] eClassFields = eClass.getDeclaredFields();
            for (Field field : eClassFields) {
                field.setAccessible(true);
                TableId tableId = field.getAnnotation(TableId.class);
                if(tableId!=null){
                    flag=true;
                    where+=tableId.value()+"='"+field.get(e)+"'";
                }else{
                    TableField tableField = field.getAnnotation(TableField.class);
                    if(tableField!=null){
                        sql.append(tableField.value()+"='"+field.get(e)+"',");
                    }else {
                        sql.append(field.getName() + "='" + field.get(e) + "',");
                    }
                }
            }

            if(flag==false){
                throw new RuntimeException("No primary key annotation added！");
            }

            String SQL=sql.substring(0,sql.lastIndexOf(","))+where;

            connection=DBUtil.getConn();
            ps=connection.prepareStatement(SQL);
            int i = ps.executeUpdate();
            return 1;
        }catch (Exception o){
            o.printStackTrace();
        }finally {
            DBUtil.closeAll(res,ps,connection);
        }
        return 0;
    }

    public List<E> findAll(){

        List<E> list=new ArrayList<>();

        StringBuffer sql=new StringBuffer("select * from ");
        try {
            TableName tableName = clazz.getAnnotation(TableName.class);
            if (tableName != null) {
                sql.append(tableName.value());
            } else {
                sql.append(clazz.getSimpleName());
            }

            //System.out.println(sql);

            connection = DBUtil.getConn();
            ps = connection.prepareStatement(sql.toString());
            res = ps.executeQuery();

            while (res.next()){
                Object obj = clazz.newInstance();

                Field[] declaredFields = clazz.getDeclaredFields();
                for (Field field : declaredFields) {
                    field.setAccessible(true);
                    TableName annotation = field.getAnnotation(TableName.class);
                    if(annotation!=null){
                        field.set(obj,res.getObject(annotation.value()));
                    }else{
                        field.set(obj,res.getObject(field.getName()));
                    }
                }
                list.add((E) obj);
            }

        }catch (Exception o){
            o.printStackTrace();
        }finally {
            DBUtil.closeAll(res,ps,connection);
        }
        return list;
    }
}

        DBUtil:

package com.lqh.utils;

import java.io.FileInputStream;
import java.sql.*;
import java.util.Properties;

/**
 * @Author Li Qinghua
 * @Create 2022/7/14 20:03
 */
public class DBUtil {
    private static String driverName;
    private static String url;
    private static String username;
    private static String password;

    static {
        try {
            Properties properties = new Properties();

            //加载属性配置文件
            properties.load(new FileInputStream("E:\\IDEA练习\\高级\\手撕ORM框架\\src\\main\\resources\\db.properties"));

            //读取属性配置文件的内容
            driverName = properties.getProperty("jdbc.driverName");
            url = properties.getProperty("jdbc.url");
            username = properties.getProperty("jdbc.username");
            password = properties.getProperty("jdbc.password");
        }catch (Exception e){
            e.printStackTrace();
        }
    }

    public static Connection getConn() throws Exception{
        Class.forName(driverName);
        Connection connection = DriverManager.getConnection(url,username,password);
        return connection;
    }

    public static void closeAll(ResultSet res, PreparedStatement ps,Connection connection){
        try {
            if(res!=null){
                res.close();
            }
        } catch (SQLException throwables) {
            throwables.printStackTrace();
        }
        try {
            if(ps!=null){
                ps.close();
            }
        } catch (SQLException throwables) {
            throwables.printStackTrace();
        }
        try {
            if(connection!=null){
                connection.close();
            }
        } catch (SQLException throwables) {
            throwables.printStackTrace();
        }
    }
}

测试:

        Test:

package com.lqh;

import com.lqh.dao.StudentDao;
import com.lqh.entity.Student;

import java.util.List;

/**
 * @Author Li Qinghua
 * @Create 2022/7/14 20:31
 */
public class Test {

    StudentDao sd=new StudentDao();

    @org.junit.Test
    public  void testInsert() {
        int insert = sd.insert(new Student(5,"王五4",25,"周口"));
    }

    @org.junit.Test
    public void testUpdate(){
        int update = sd.update(new Student(1,"ll",9,"zz"));
    }

    @org.junit.Test
    public void testUpdate02(){
        int id = sd.update02(new Student(1,"pp",19,"zpz"));
    }

    @org.junit.Test
    public void testDelete(){
        int delete = sd.delete(5);
    }

    @org.junit.Test
    public void testFindAll(){
        List<Student> list = sd.findAll();
        System.out.println(list);
    }
}

db.properties

jdbc.driverName=com.mysql.cj.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/db2?serverTimezone=Asia/Shanghai
jdbc.username=root
jdbc.password=pAssW0rd

核心代码在BaseDao中

lqh12138
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
手撕ORM框架（泛型+注解+反射）
wk3510的博客
11-01 436
ORM框架的单表的CRUD。
手撕Spring框架
qq_45605535的博客
04-09 399
文章目录IOC传统的方法赋值bean1.xmldept类empt类使用自动装配的方法进行赋值自动装配的方法一之byName自动装配方法二之byTypespring连接数据库最传统的方法连接数据库使用配置文件的方式连接数据库基于注解方式的IOC操作之Bean管理什么是注解对Bean管理中创建对象提供注解组件包扫描之控制组件扫描内容的做法实现属性的注入属性的自动注入,像这些就不需要显示声明get和set方法，逐步优化了代码。@Resource替代@Qualifier和@Autowired普通属性的注入纯注解的开
手撕RPC框架
weixin_30675247的博客
04-02 91
手撕RPC 使用Netty+Zookeeper+Spring实现简易的RPC框架。阅读本文需要有一些Netty使用基础。 服务信息在网络传输，需要讲服务类进行序列化，服务端使用Spring作为容器。服务端发布服务，将接口的全路径当做节点名称，服务的ip+端口作为节点值，存储到Zookeeper中。客户端调用的时候，去Zookeeper查询，获得提供该接口的服务器ip和端口，通过Netty进行调...
手撕神经网络框架（numpy）
songsongL的博客
04-23 541
神经网络基本步骤loaddatainitializeforwardbackwardupdateover 任何神经网络肯定都有这些基本操作过程，每一小步中又会有各种不同的策略。 我是跟着吴恩达大佬做的一些实践，对神经网络的理解特别有用 loaddata 这一步包括归一化、小批量读取等等操作。这里只做一些最简单的处理。 def load_dataset(): train_dataset = h5py.File('D:/PyWorkspace/DeepLearning/datasets/train_ca
手撕ORM(泛型+注解+反射)
BUG专业户
07-16 350
手撕ORM（对象关系映射框架）IDEA将项目打包成jar包 jar包打包到自己的本地仓库 打包的jar包中Lombok包不能使用，报错
手写ORM框架笔记.txt
07-06
### 手写ORM框架知识点详解 #### 一、ORM框架概念 ORM（Object Relational Mapping）即对象关系映射，是一种编程技术，用于将关系数据库中的数据与面向对象语言（如Java）中的对象进行映射。它使得开发人员能够通过...
手写ORM框架.java
12-22
博文资源
简单高效的ORM框架
11-07
在现代软件开发中，ORM框架扮演着重要的角色，它使得开发者无需关注底层SQL语句，就能方便地进行数据操作，大大提高了开发效率。 "简单高效"是ORM框架的重要特征。简单意味着易于理解和使用，让开发者能够快速上手...
sqltoy-orm框架系统-其他
06-11
sqltoy-orm是比hibernate+myBatis更加贴合项目的orm框架，具有hibernate增删改的便捷性同时也具有比myBatis更加灵活优雅的自定义sql查询功能。 sqltoy-orm支持以下数据库: oracle 从oracle11g到19c db2 9.5+,建议从...
通过例子手撕架构模式
sydMobile专栏
12-04 186
更多精品文章分类 关于架构 关于架构的概念很宽泛，不是一句 MVP、MVC、MVVM 就能说清楚的。 一般开发软件的时候，我们是如何进行架构设计的呢？ 首先一个 APP 软件是一个大的系统，我们通常可以把这个大的系统划分为许多个小的模块，比如：登录注册功能，首页展示功能、个人信息功能等等某个具体的模块的功能。然后我们就可把这几个相对独立的模块分别划分给不同的人员进行开发。 当然在进行模块划分前，...
手撕ORM 框架(泛型+注解+反射)
Ysuhang的博客
07-18 250
用于实体类上TableName表名和实体类名不一致时使用TableField列名和属性名不一致时使用TablePrimaryKey主键上使用,用来区别于其他属性。
Spring之手撕框架核心逻辑
qq_45065241的博客
06-09 171
Spring之手撕框架核心逻辑 前言： 相比大多数开发者都用过Spring，但是由于工作性质原因一直没有时间或经历去研究和整理Spring底层到底是怎么运作的，核心逻辑又是什么。下面小编通过手写一套简单的Spring框架底层逻辑，帮助大家更好的认识Spring，也为想要冲击大厂的小伙伴提供一些文章资料。 相关项目资源已经上传。下载地址：https://download.csdn.net/download/qq_45065241/19496977?spm=1001.2014.3001.5503 手写实
Properties的load方法
weixin_33940102的博客
01-05 892
2019独角兽企业重金招聘Python工程师标准>>> ...
JDBC从入门到精通
siriling的博客
08-03 111
一、JDBC 简介 Java数据库连接，（Java Database Connectivity，简称JDBC）是Java语言中用来规范客户端程序如何来访问数据库的应用程序接口，提供了诸如查询和更新数据库中数据的方法。 我们通常说的JDBC是面向关系型数据库的。 基本环境搭建 Maven 此为父项目 <?xml version="1.0" encoding="UTF-8"?> <project xmlns="http://maven.apache.org/POM/4.0.0"
javaweb项目加载properties时找不到路径----properties.load(new FileInputStream(“src\jdbc.properties”))
m0_45263525的博客
10-06 2073
Javaweb项目中使用properties.load(new FileInputStream("src\\jdbc.properties"));加载文件时，出现文件没有找到的异常
纯手撕一个JDBC通用操作框架
05-21
学完JDBC之后,我们应该想着如何去更快更便捷的使用JDBC去操作数据的增删改查很多同学或多或少了解过例如由Apache提供的DBUtis、Spring提供的JDBCTemplae等操作框架，他们可以极大的简化我们日常操作JDBC的步骤。与其授人以鱼不如授人以渔,我们将花一点点时间 来自己手撕一个类似于上述两个框架的通用处理框架,自己手写 了解其原理 了解其思想。对于面试提升、技能提升有莫大的帮助。
JAVA进阶补充
2301_80150315的博客
08-15 885
概念：把已经有的方法拿过来用，当作函数式接口中抽象方法的方法体条件：引用处必须是函数式接口被引用的方法需要已经存在被引用方法的形参和返回值需要跟抽象方法的形参和返回值保持一致被引用方法的功能需要满足当前需求：方法引用符意义：就是为让控制台的报错信息更加的见名知意自定义异常的步骤：定义异常类写继承关系空参构造带参构造​file对象就表示一个路径，可以是文件的路径、也可以是文件夹的路径；这个路径可以是存在的，也允许是不存在的构造方法描述根据文件路径创建对象。
手撕快排——三种实现方法（附动图及源码）
最新发布
jsjs1346的博客
08-16 575
🤖💻👨‍💻👩‍💻🌟🚀🤖🌟👨‍💻👩‍💻👨‍💻👩‍💻🚀是一种高效的排序算法，广泛应用于各种场景。它采用策略，将一个数组分成两个子数组，然后递归地对这两个子数组进行排序。本文将介绍三种快速排序的实现方法，并附上相应的源码。⚙️一、快速排序的基本原理一个基准元素（pivot）分成两个子数组递归合并O(n log n)O(n log n)O(n^2)后文我们将给出优化方案O(log n)📚三、实现霍尔方法是快速排序原始版本中使用的分区方法。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值