数据库学习（3） - 数据库工具（基于注解实现数据库的连接，以及简单的记录插入、查询、删除、修改操作）

最新推荐文章于 2021-02-25 21:57:40 发布
最新推荐文章于 2021-02-25 21:57:40 发布
阅读量304 收藏
点赞数
分类专栏： 工具 Java 文章标签： 工具
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/CactusStory_/article/details/97903472
版权
Java 同时被 2 个专栏收录
14 篇文章 0 订阅
订阅专栏
工具
4 篇文章 0 订阅
订阅专栏

关于注解

关于注解

某个类与其对应数据库表的映射关系用注解来表示

表注解

应用于类，在使用该注解时其属性 name 必须赋值

package com.mec.orm.annotation;

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

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface Table {
	String name();
}

关键字注解

作用于类的成员，来表明该成员是否对应表中的关键字
如果该成员含有这个注解，则表明该成员所对应的字段为该表的关键字

package com.mec.orm.annotation;

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

@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
public @interface Key {
	
}

字段注解

字段名默认为空串，如果类的成员名与字段名相同则不需要重新给column属性赋值

package com.mec.orm.annotation;

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

@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
public @interface Column {
	String column() default "";
}

关于数据库工具

PropertyColumn 类

该类主要处理字段与其对应类的成员的关系

package com.mec.orm.core;

import java.lang.reflect.Field;
import java.sql.ResultSet;
import java.sql.SQLException;

public class PropertyColumn {
	private String column;
	private Field field;
	
	public PropertyColumn() {
	}
	
	public void setProperty(ResultSet resultSet,Object obj) {
		try {
			Object value = resultSet.getObject(column);
			field.setAccessible(true); 
			field.set(obj, value);     
		} catch (SQLException e) {
			e.printStackTrace();
		} catch (IllegalArgumentException e) {
			e.printStackTrace();
		} catch (IllegalAccessException e) {
			e.printStackTrace();
		}
	}

	public String getColumn() {
		return column;
	}

	public void setColumn(String column) {
		this.column = column;
	}

	public Field getField() {
		return field;
	}

	public void setField(Field field) {
		this.field = field;
	}

	@Override
	public String toString() {
		return column + "< - >" + field;
	}
	
}

ClassTable类

该类主要处理某个类与其对应表的关系

package com.mec.orm.core;

import java.sql.ResultSet;
import java.util.ArrayList;
import java.util.List;

public class ClassTable {
	private Class<?> klass;
	private String table;
	private List<PropertyColumn> fieldList;
	private PropertyColumn id;
	
	ClassTable() {
		fieldList = new ArrayList<>();
	}
	
	void setFieldFromResultSet(ResultSet resultset,Object obj) {
		for(PropertyColumn field : fieldList) {
			field.setProperty(resultset, obj);
		}
	}
		
	void addProperty(PropertyColumn property) {
		fieldList.add(property);
	}
	
	Class<?> getKlass() {
		return klass;
	}

	void setKlass(Class<?> klass) {
		this.klass = klass;
	}

	String getTable() {
		return table;
	}

	void setTable(String table) {
		this.table = table;
	}

	List<PropertyColumn> getFieldList() {
		return fieldList;
	}

	void setFieldList(List<PropertyColumn> fieldList) {
		this.fieldList = fieldList;
	}

	PropertyColumn getId() {
		return id;
	}

	void setId(PropertyColumn id) {
		this.id = id;
	}

	String getIdString() {
		return table + "." + id.getColumn();
	}
	
	String getColumnString() {
		StringBuffer res = new StringBuffer();
		
		boolean first = true;
		for(PropertyColumn field : fieldList) {
			res.append(first ? "" : ", ")
		    	.append(table).append(".") 
			    .append(field.getColumn());
			first = false;
		}
		return res.toString();
	}
	
	int getfieldCount() {
		return fieldList.size();
	}
	
	@Override
	// 便于测试
	public String toString() {
		StringBuffer res = new StringBuffer("类");
		
		res.append(klass.getName()).append('\n')
				.append("表:").append(table).append('\n');
		
		for(PropertyColumn pc : fieldList) {
			res.append('\t').append(pc.getField().getName())
					.append("< - > ")
					.append(pc.getColumn())
					.append('\n');
		}
		res.append(id).append('\n');
		return res.toString();
	}
	
}

ClassTableFactory类

该类主要解析类与表的映射关系（支持xml文件和注解表示）

ClassTableFactory 方法：解析该类的注解得到映射关系
loadMapping方法：利用xml解析工具，解析xml文件得到映射关系

XML解析工具

package com.mec.orm.core;

import java.lang.reflect.Field;
import java.util.HashMap;
import java.util.Map;

import org.w3c.dom.Element;

import com.mec.orm.annotation.Column;
import com.mec.orm.annotation.Key;
import com.mec.orm.annotation.Table;
import com.mec.util.XMLParser;

public class ClassTableFactory {
	private static final Map<String,ClassTable> classtableMap;

	static {
		classtableMap = new HashMap<>();
	}

	public ClassTableFactory() {
	}
	
	public static void classTableParser(Class<?> klass) {
		if(!klass.isAnnotationPresent(Table.class)) {
			return;
		}
		Table table = klass.getAnnotation(Table.class);
		String tablename = table.name();
		ClassTable ct = new ClassTable();
		ct.setKlass(klass);
		ct.setTable(tablename);
		
		Field[] fields = klass.getDeclaredFields();
		boolean hasKey = false;
		
		for(Field field : fields) {
			if (!field.isAnnotationPresent(Column.class)) {
				continue;
			}
			String column = field.getName();
			Column f = field.getAnnotation(Column.class);
			String col = f.column();
			if(col.length() > 0) {
				column = col;
			}
			PropertyColumn property = new PropertyColumn();
			property.setField(field);
			property.setColumn(column);
			ct.addProperty(property);
			
			if(!hasKey && field.isAnnotationPresent(Key.class)) {
				ct.setId(property);
				hasKey = true;
			}
		}
		classtableMap.put(klass.getName(), ct);
	}
	
	public static void loadMapping(String path) {
		try {
			new XMLParser() {
				
				@Override
				public void dealElement(Element element, int index) {
					String className = element.getAttribute("class");
					String tableName = element.getAttribute("table");
					
					ClassTable ct = new ClassTable();
					try {
						Class<?> klass = Class.forName(className);
						ct.setKlass(klass);
						ct.setTable(tableName);
						new XMLParser() {
							
							@Override
							public void dealElement(Element element, int index) {
								String id = element.getAttribute("key");
								String property = element.getAttribute("property");
								String column = element.getAttribute("name");
								
								PropertyColumn pc = new PropertyColumn();
								try {
									pc.setField(klass.getDeclaredField(property));
									pc.setColumn(column);
									
									if(id.length() > 0) {
										ct.setId(pc);
									}
									ct.addProperty(pc);
								} catch (NoSuchFieldException e) {
									e.printStackTrace();
								} catch (SecurityException e) {
									e.printStackTrace();
								}						
							}
						}.parse(element,"column");
					} catch (ClassNotFoundException e) {
						e.printStackTrace();
					}
					classtableMap.put(className, ct);
				}
			}.parse(XMLParser.loadXML(path),"mapping");
		} catch (Exception e) {
			e.printStackTrace();
		};
	}
	
	public static ClassTable getClassTable(Class<?> klass) {
		return classtableMap.get(klass.getName());
	}
	
	public static ClassTable getClassTable(String className) {
		return classtableMap.get(className);
	}
	
}

Database 类

properties解析工具

结合使用properties解析工具完成数据库的连接，以及记录的插入、修改、删除、查询等操作

package com.mec.orm.core;

import java.lang.reflect.Field;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;

import com.mec.util.PropertiesParser;

public class Database { 
	private static Connection connection;
	
	public Database() {
	}
	
	public static void loadDatabaseConfig(String path) {
		PropertiesParser.loadProperties(path);
	}
	
	private static Connection getConnection() {
		if(connection == null) {
			try {
				Class.forName(PropertiesParser.value("driver"));
				connection = (Connection) DriverManager.getConnection(
						PropertiesParser.value("url"),
						PropertiesParser.value("user"),
						PropertiesParser.value("password")
						);
			} catch (ClassNotFoundException e) {
				e.printStackTrace();
			} catch (SQLException e) {
				e.printStackTrace();
			}
		}
		return connection;
	}

	@SuppressWarnings("unchecked")
	public <T> List<T> list(Class<?> klass){
		ClassTable ct = getClassTable(klass);
		if(ct == null) {
			return null;				
		}
		
		String sql = "SELECT " + ct.getColumnString() + " FROM " + ct.getTable();
		List<T> result = new ArrayList<>();
		try {
			PreparedStatement state = getConnection().prepareStatement(sql);
			ResultSet rs = state.executeQuery();
			
			while(rs.next()) {
				Object obj = klass.newInstance();
				ct.setFieldFromResultSet(rs, obj);
				result.add((T) obj);
			}
		} catch (SQLException e) {
			e.printStackTrace();
		} catch (InstantiationException e) {
			e.printStackTrace();
		} catch (IllegalAccessException e) {
			e.printStackTrace();
		}
		return result;
	}
	
	@SuppressWarnings("unchecked")
	public <T> T get(Class<?> klass,Object id) {		
		ClassTable ct = getClassTable(klass);
		if(ct == null) {
			return null;				
		}
		
		String sql = "SELECT " + ct.getColumnString() + " FROM " + ct.getTable()
		+ " WHERE " + ct.getIdString() + "=?";
		
		Connection connection = getConnection();
		try {
			PreparedStatement state = connection.prepareStatement(sql);
			state.setObject(1,id);
			ResultSet rs = state.executeQuery();
			
			if(rs.next()) {
				Object obj = klass.newInstance();
				ct.setFieldFromResultSet(rs, obj);
				return (T) obj;
			}
		} catch (SQLException e) {
			e.printStackTrace();
		} catch (InstantiationException e) {
			e.printStackTrace();
		} catch (IllegalAccessException e) {
			e.printStackTrace();
		}
    	return null;
	}
	
	
	public <T> int save(T obj){
		Class<?> klass = obj.getClass();
		ClassTable ct = getClassTable(klass);
		
		String sql = getSQLInsertInto(ct);
		PreparedStatement state = setObject(sql, obj);
		
		try {
			state.executeUpdate();
		} catch (SQLException e) {
			e.printStackTrace();
		}		
		
		return 0;
	}
	
	public <T> int modify(T obj,Object id) {
		Class<?> klass = obj.getClass();
		ClassTable ct = getClassTable(klass);
		
		String sql = getUpdateSQL(ct);
		sql = sql.replaceAll(","," = ?,") + "= ?";
		sql = sql + " WHERE "+ ct.getIdString() + "=" + id;
		PreparedStatement state = setObject(sql, obj);
		
		try {
			state.executeUpdate();
		} catch (SQLException e) {
			e.printStackTrace();
		}		
		
		return 0;
	}
	
	public <T> int delete(T obj,Object id) {
		Class<?> klass = obj.getClass();
		ClassTable ct = getClassTable(klass);
		
		StringBuffer sql = new StringBuffer();
		
		sql.append("DELETE FROM ").append(ct.getTable())
		.append(" WHERE ").append(ct.getIdString())
		.append("=").append(id);
		
		Connection connection = getConnection();
		try {
			PreparedStatement state =  connection.prepareStatement(sql.toString());
			state.executeUpdate();
		} catch (SQLException e) {
			e.printStackTrace();
		}
		
		return 0;
	}
	
	private String getUpdateSQL(ClassTable ct) {
		StringBuffer sql = new StringBuffer();
		
		sql.append("UPDATE ").append(ct.getTable())
			.append(" SET ").append(ct.getColumnString());					
		
		return sql.toString();
	}
	
	private PreparedStatement setObject(String sql,Object obj) {
		Connection connection = getConnection();
		PreparedStatement state = null;
		try {
			state = connection.prepareStatement(sql);
			Class<?> klass = obj.getClass();
			Field[] fields = klass.getDeclaredFields();
			int i = 1;
			for(Field field : fields) {
				field.setAccessible(true);
				Object value;
				try {
					value = field.get(obj);
				} catch (Exception e) {
					value = null;
				}
				state.setObject(i++, value);
			}
		} catch (SQLException e) {
			e.printStackTrace();
		}
		return state;
	}
	
	private String getSQLInsertInto(ClassTable ct) {
		StringBuffer sql = new StringBuffer("INSERT INTO ");
		sql.append(ct.getTable()).append(" (")
		   .append(ct.getColumnString()).append(") ")
		   .append("VALUES(");
		
		int count = ct.getfieldCount();
		boolean first = true;
		for(int i = 0;i < count;i++) {
			sql.append(first ? "?" : ",?");
			first = false;
		}
		sql.append(")");
		return sql.toString();
	}
	
	private ClassTable getClassTable(Class<?> klass) {
		
		ClassTable ct = ClassTableFactory.getClassTable(klass);
		if(ct == null) {
			ClassTableFactory.classTableParser(klass);
			ct = ClassTableFactory.getClassTable(klass);
			
		}
		return ct;
	}
	
	
	public int executeUpdate(String SQLString) {
		Connection connection = getConnection();
		try {
			PreparedStatement state = connection.prepareStatement(SQLString);
			return state.executeUpdate();
		} catch (SQLException e) {
			e.printStackTrace();
		}
		
		return -1;
	}

	public ResultSet executeQuery(String sql) {
		ResultSet rs = null;
		Connection connection = getConnection();
		try {
			PreparedStatement state = connection.prepareStatement(sql);
			return state.executeQuery();
		} catch (SQLException e) {
			e.printStackTrace();
		}
		return rs;
	}
	
}

测试代码

SDMmodel类

package com.mec.orm.model;

import com.mec.orm.annotation.Column;
import com.mec.orm.annotation.Key;
import com.mec.orm.annotation.Table;

@Table(name = "sys_sch_dep_maj_info")
public class SDMmodel {
	@Column
	@Key
	private String id;
	@Column
	private String name;
	@Column
	private boolean status;
	
	public SDMmodel() {
	}

	public SDMmodel(String id, String name, boolean status) {
		this.id = id; 
		this.name = name;
		this.status = status;
	}

	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 boolean isStatus() {
		return status;
	}

	public void setStatus(boolean status) {
		this.status = status;
	}

	@Override
	public String toString() {
		StringBuffer res = new StringBuffer();
		
		res.append("'" + getId() + "','" 
				   + getName() + "'," + (isStatus()? "1" : "0"));
		
		return res.toString();
	}
	
}


package com.mec.orm.test;

import com.mec.orm.core.Database;
import com.mec.orm.model.SDMmodel;

public class TestForOrm {
	public static void main(String[] args) {
		Database.loadDatabaseConfig("/dataBase.properties");
		Database database = new Database();
		SDMmodel sdm = new SDMmodel("060101","vivi",true);
		database.save(sdm);
	//	SDMmodel sdmNew = new SDMmodel("060101", "sehun", true);
	//	database.modify(sdmNew,sdmNew.getId());
	//  database.delete(sdm, sdm.getId());
	}
}

运行结果

原始数据库表
原始数据库表
执行save()方法之后
执行save()方法之后

CactusStory_
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
HarmonyOS之基于Data Ability的关系型数据库操作方法.zip
08-02
本示例通过注解和继承来实现数据库和表的创建，实现了数据库的升级、备份、删除、恢复，实现了表的增删改查，并监听数据变化。 @Database注解，且继承了OrmDatabase的类，对应关系型数据库； @Entity注解，且继承了...
数据库连接查询操作
weixin_33743248的博客
07-12 117
1.内连接（inner join） 返回两个表符合条件的数据。 查询： SELECT DISTINCT p.user_id,p.user_name,r.c_id,r.job_id FROM person p INNER JOIN relative r ON p.user_id=r.user_id 结果集： 1001 小明 301 201 1...
数据库学习（1） - 与properties文件解析结合实现数据库连接、简单数据库表的插入、查询、删除、修改
慢慢来吧，都会有的。
07-25 259
数据库连接步骤 1. **导入数据库驱动** 2. **建立数据库连接** 3. **构造字符串类型的SQL语句** 4. **建立SQL预编译** 其中前两步，在多次数据库查询时，只要执行一次，并保证数据库连接即可。 SELECT语句、UPDATE语句、INSERT INTO 语句、DELETE 语句
java数据库连接以及基本的增删改查操作在java中实现
weixin_43843824的博客
06-26 513
java连接mysql数据库及其相关基本操作 要连接数据库，首先，确保得自己已经正确安装好了数据库。确认方法：运行mysql程序输入超级管理员密码后可以输入数据库语句运行。效果如下图所示， 已经确认好后，打开java，新建一个程序。在目录下新建一个文件夹导入驱动包，具体步骤如下： 1.新建文件夹： 2.导入下载好的驱动包 驱动包资源分享在这里：链接：https://pan.baidu.com...
自定义一个注解来获取数据库的链接
KevinLoveJava
01-05 704
import java.lang.annotation.ElementType; import java.lang.annotation.Retention; import java.lang.annotation.RetentionPolicy; import java.lang.annotation.Target; @Retention(RetentionPolicy.RUNTIME)
MySql数据库操作语言(插入、修改、删除)
芒种、的博客
07-05 1996
DML语言：数据库操作语言 插入： insert 修改： update 删除： delete 一、插入语句 1. 方式一： 语法： insert into 表名（列名,...） values(值1,...); 插入值的类型要与列的类型一致或者兼容 insert into beauty(id,name,sex,borndate,phone,photo,boyfriend_id) values(13,"唐艺昕","女","1990-4-23","189888888",null,2); 不可以为null
HarmonyOS之实现对象关系映射数据库的升级、备份、删除、恢复以及表的增删改查.zip
08-03
本示例通过注解和继承来实现数据库和表的创建，实现了数据库的升级、备份、删除、恢复，实现了表的增删改查，并监听数据变化。 @Database注解，且继承了OrmDatabase的类，对应关系型数据库； @Entity注解，且继承了...
HarmonyOS之实现对象关系映射ORM数据库的升级、备份、删除、恢复以及表的增删改查
最新发布
05-15
本示例通过注解和继承来实现数据库和表的创建，实现了数据库的升级、备份、删除、恢复，实现了表的增删改查，并监听数据变化。 @Database注解，且继承了OrmDatabase的类，对应关系型数据库； @Entity注解，且继承了...
Android Room数据库多表查询的使用实例
01-20
Android-Room数据库（介绍） 前言 在SQLite数据库中，我们可以指定对象之间的关系，因此我们可以将一个或多个对象与一个或多个其他对象绑定。这就是所谓的一对多和多对多的关系。 既然要多表查询，所以表之间就得有...
Java实验8 数据库.doc
05-02
本专栏主要为Java程序设计（基础）实验报告和Java程序设计（进阶）...进阶篇有反射、泛型、注解、网络编程、多线程、序列化、数据库、Servlet、JSP、XML解析、单例模式与枚举。本专栏主要为Java入门者提供实验参考。
spring-dao-anno全注解方式连接数据库，进行增删改查示例
qq_45753477的博客
11-13 286
基于Maven项目： pom.xml <dependencies> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-context</artifactId> <version>5.2.1.R...
mybatis generator 代码生成工具使用、带数据库注释及完美示例代码下载
a913396的博客
06-09 827
1 配置文件start&lt;?xml version="1.0" encoding="UTF-8"?&gt;&lt;!DOCTYPE generatorConfiguration  PUBLIC "-//mybatis.org//DTD MyBatis Generator Configuration 1.0//EN"  "http://mybatis.org/dtd/mybatis-genera...
Oracle_SQL 数据操作和查询
ageeklet的博客
09-05 1647
1、SQL简介 SQL 是结构化查询语言（Structured Query Language），专门用于数据存取、数据更新及数据库管理等操作。 在 Oracle 开发中，客户端把 SQL 语句发送给服务器，服务器对 SQL 语句进行编译、执行，把执行的结果返回给客户端。Oracle SQL 语句由如下命令组成： 数据定义语言（DDL），包括 CREATE（创建）命令、ALTER（修改）命令、...
java用注解来连接mysql_java自定义注解的方式连接MySQL数据库来走进注解
weixin_42433470的博客
02-25 359
最近在学习spring。里面有一个非常的强大的功能叫做注解，刚才，同学们的每日一讲讲到了注解，学以致用来总计一下注解机制什么是注解？注解(Annotation)：提供了一种安全的类似注释的机制，为我们在代码中添加信息提供了一种形式化的方法，使我们可以在稍后某个时刻方便的使用这些数据(通过解析注解来使用这些数据)，用来将任何的信息或者元数据与程序元素(类、方法、成员变量等)进行关联。其实就是更加直观...
oracle中的处理数据增删改查
cgd_8523的博客
05-30 398
SQL&gt; /* -- SQL的类型 -- 1、DML（Data Manipulation Language 数据操作语言）: select insert update delete -- 2、DDL(Data Definition Language 数据定义语言): create table,alter table,truncate table,drop table -- ...
学习使用TestNG数据驱动连接MySQL
asd0654123的博客
01-22 2026
一、MySQL数据库测试数据准备 -- 创建数据库 CREATE DATABASE test; -- 使用该数据库 use test; -- 创建data_provider表，供测试使用 CREATE TABLE data_provider ( username VARCHAR (20), userpasswd VARCHAR (20), playgame VARCHA...
Swing学习（2） - 下拉菜单（JMenuBar、JMenu、JMenuItem）、弹出式菜单（jpopupMenu）
慢慢来吧，都会有的。
07-22 1439
基本知识 JMenuBar菜单栏 JMenu一级菜单 JMenuItem菜单选项 JPopupMenu弹出式菜单
Java 序列号
慢慢来吧，都会有的。
11-13 678
序列号实现
算法练习 - 整数反转【Java】
慢慢来吧，都会有的。
11-14 543
判断反转之后的数是否溢出
数据库插入数据时，自动脱敏，使用自定义注解如何实现
07-08
对于数据库插入数据时的自动脱敏，可以通过自定义注解结合拦截器来实现。 首先，你可以定义一个注解，比如`@SensitiveData`，用于标记需要进行脱敏的字段。例如： ```java @Retention(RetentionPolicy.RUNTIME) @...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值