精华内容
下载资源
问答
  • 文件包含一个工具类,是mysql数据库表生成实体工具类,压缩文件中有相关jar包。目前符合我的日常需要,有缺陷的地方大家一起补充.....欢迎留言,谢谢
  • MySql学习笔记--MySql数据库表远程映射

    万次阅读 热门讨论 2018-02-27 14:47:33
    现在在做的项目分为7个服务,其中有一个单服务,对应的数据库有一张存储的是单的数据,其他服务用到这张表基本是需要将本服务的中对应的id转换为对应的name。项目初期没有分库分表,但是项目稳定一版后,架构...

    强烈推荐一个大神的人工智能的教程:http://www.captainbed.net/zhanghan

    需求背景

         现在在做的项目分为7个服务,其中有一个单表服务,对应的数据库有一张表存储的是单表的数据,其他服务用到这张表基本是需要将本服务的表中对应的id转换为对应的name。项目初期没有分库分表,但是项目稳定一版后,架构方面考虑分库分表,这样就涉及到一个服务在开发阶段不能随意连接其他服务的表进行操作,为了解决此问题,我们考虑将单表服务的表远程映射到其他服务的数据库中,这样做,当单表服务的数据有变动时,其他服务对应的单表数据表数据也会同步!

    MySQL开启federated引擎

    一、Windows环境

    1.查看当前federated引擎是否开启

        使用navicat连接mysql之后,F6键打开命令行界面,输入指令:show engines;

    2.开启federated引擎

    ①mysql -uroot -proot 连接mysql

    ②查看mysql的安装目录和数据存放路径

    ③找到mysql的数据存放路径,会找到相应的my.ini文件,如果找到之后叫其他的名字,可以改名为my.ini,打开my.ini文件在其中加上federated

    3.重启mysql服务

      ①快捷键win+X+G打开计算机管理,找到mysql的服务,将mysql的服务停掉之后再启动

     

    4.再次使用show engines;命令查看federated引擎是否开启

    二、Linux环境

    1.连接mysql,使用命令show engines;查看引擎是否开启

    2.使用命令whereis my.cnf查看配置文件的位置(我的在/etc/my.cnf)

    3.使用命令vim /etc/my.cnf编辑配置文件

    4.配置文件中加上federated

    5.使用命令service mysqld restart重启mysql服务

    6.再次使用命令show engines;查看是否开启成功

    映射远程表

         现在假设有两套库,一套在服务器192.168.22.10上,一套在我本地127.0.0.1上,将单表服务分在服务器上,我本地数据库上没有单表的数据表,只有我们本服务的表。服务器上的数据库名称叫itoo,单表有一张表叫t_dictionary,现在将服务器上的t_dictionary表映射到我本地库中,在我本地,连接mysql,执行以下命令:

    CREATE TABLE `t_dictionary` (
      `id` varchar(22) NOT NULL,
      `operator` varchar(20) DEFAULT NULL COMMENT '操作人',
      `is_delete` tinyint(2) DEFAULT NULL COMMENT '是否删除',
      `dictionary_code` varchar(20) DEFAULT NULL COMMENT '字典code',
      `dictionary_name` varchar(20) DEFAULT NULL COMMENT '字典类型名称',
      `timespan` timestamp NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP COMMENT '时间戳',
      PRIMARY KEY (`id`),
      KEY `FK_9wjh2c0vbqiu5qdgnhay8t9le` (`dictionary_type_id`) USING BTREE
    ) ENGINE=FEDERATED    
    CONNECTION='mysql://admin:admin@192.168.22.10:3306/itoo/t_dictionary';

        其中创建的表结构要和服务器上的一模一样,ENGINE为FEDERATED,CONNECTION中的admin:admin表示服务器的用户名:密码,itoo是服务器上的数据库名称,t_dictionary是服务器上的表名称,执行完之后,在本地库中将看到t_dictionary表已经映射过来了。

    测试

        在服务器上将这张映射的表修改一条数据,会发现本地库中这张映射过来的表数据同时改变了!到此基本可以确定这样远程映射表是成功了!我将代码中的数据库地址修改为我本地,执行某个接口的查询操作,成功查询回正确的结果,标明远程映射表成功!

     

    展开全文
  • 数据库表映射成和表名相同的实体类
  • 数据库表关联映射

    千次阅读 2018-11-29 14:55:14
    数据之间的关联关系分为3种:一对一,一对多,多对多. 一对一 是将数据垂直切分,其实是不常见的,或不常用的.也就是A的一条记录对应B的一条记录, 例如:一个系统必然有员工(包含字段:EmployeeId、姓名、性别...

    数据表之间的关联关系分为3种:一对一,一对多,多对多.

    一对一

     是将数据表垂直切分,其实是不常见的,或不常用的.也就是A表的一条记录对应B表的一条记录, 例如:一个系统必然有员工表(包含字段:EmployeeId、姓名、性别、年龄、电话、地址等),每个员工都为一个用户,所以还有张 User 表(包含字段:UserId(关联 EmployeeId)、用户名、密码、角色等),这样你会发现,整合为一张表是否不太妥当?因为,User 的记录只会在登录时用到,感觉有点违背三大范式中的“确保每列都和主键列直接关联,而不是间接关联”。
     还有种情况,这就要根据具体的业务来决定了。如果,当一张表的字段过于太多,而很多字段可能只有在某些情况下,才会使用到,这时也可以考虑使用一对一设计。
    

    优点

    1. 便于管理、可提高一定的查询速度

    2. 减轻 CPU 的 IO 读写,提高存取效率。

    3. 符合数据库设计的三大范式。

    4. 符合关系性数据库的特性。

    Ø 缺点

    1. 增加一定的复杂程度,程序中的读写难度加大。

    一对多

      是最常见的设计,就是A表的一条记录,对应B表的多条记录,且A的主键作为B表的外键这主要看以哪张表为中心,以上示例以 A 表为中心,就是一对多,如果以 B 表为中心,则是多对一。举几个例子:
    
    1. 班级表 与 学生表,一个班级对应多个学生,或者多个学生对应一个班级。

    2. 角色表 与 用户表,一个角色对应多个用户,或者多个用户对应一个角色。

    3. 商品表 与 图片表,一个商品对应多张图片,或者多张图片对应一个商品。

    4. 多对多

    Ø 多对多,在数据库中也比较常见,可以理解为是一对多和多对一的组合。要实现多对多,一般都需要有一张中间表(也叫关联表),将两张表进行关联,形成多对多的形式。例如:

    1. 老师表、班级表、科目表,中间表为:课程表
    1. SQL:

    –教师表

    CREATE TABLE #Teacher(TeacherId int, Name nvarchar(20));

    INSERT INTO #Teacher VALUES(1, ‘张老师’), (2, ‘王老师’);

    –班级表

    CREATE TABLE #Class(ClassId int, Name nvarchar(20));

    INSERT INTO #Class VALUES(1, ‘一班’), (2, ‘二班’);

    –课程表(关联表)

    CREATE TABLE #Courses(CoursesId int IDENTITY(1, 1), TeacherId int, ClassId int, Name nvarchar(20));

    INSERT INTO #Courses VALUES(1, 1, ‘语文’), (1, 2, ‘语文’);

    INSERT INTO #Courses VALUES(2, 1, ‘数学’), (2, 2, ‘英语’);

    SELECT T1.TeacherId, T2.Name, T1.ClassId, T3.Name, T1.Name FROM #Courses AS T1, #Teacher AS T2, #Class AS T3

    WHERE T1.TeacherId=T2.TeacherId AND T1.ClassId=T3.ClassId

    DROP TABLE #Teacher, #Class, #Courses;

    在这里插入图片描述

    转: https://www.cnblogs.com/abeam/p/7406285.html

    展开全文
  • myBatis映射数据库表

    2015-03-24 11:32:37
    在myBatis中映射数据库表mapper,model,dao
  • mysql数据库表映射实体类

    千次阅读 2018-03-13 09:53:28
    反射当前数据库下所有生成实体类; 类名、属性名、get/set方法名都采用驼峰命名 类名注释、属性注释、方法注释等 package com.xh.activiti.commons.utils; import java.io.File; import java.io.FileNotFo...

     

    分享知识 传递快乐

    • JDBC连接数据库;
    • 通过配置文件连接数据库;
    • 反射指定表生成实体类;
    • 反射当前数据库下所有表生成实体类;
    • 类名、属性名、get/set方法名都采用驼峰命名
    • 类名注释、属性注释、方法注释等
    package com.xh.activiti.commons.utils;
    
    import java.io.File;
    import java.io.FileNotFoundException;
    import java.io.FileWriter;
    import java.io.IOException;
    import java.io.InputStream;
    import java.io.PrintWriter;
    import java.sql.Connection;
    import java.sql.DatabaseMetaData;
    import java.sql.DriverManager;
    import java.sql.ResultSet;
    import java.sql.SQLException;
    import java.text.SimpleDateFormat;
    import java.util.Date;
    import java.util.HashMap;
    import java.util.LinkedList;
    import java.util.Map;
    import java.util.Properties;
    
    import org.apache.commons.lang3.StringUtils;
    
    /**
     * <p>Title: 获取数据库基本信息的工具类</p>
     * <p>Description: </p>
     * 
     * @author H.Yang
     * @QQ 1033542070
     * @date 2018年3月12日
     */
    public class GenEntityTable {
    
    	private static final String PROPERTIES_NAME = "config/db.properties";
    	private static final String PACKAGE_OUT_PATH = "com.xh.activiti.entity";// 指定实体生成所在包的路径
    	private static final String AUTHOR_NAME = "H.Yang";// 作者名字
    
    	private static String tableName = "";// 表名
    	private static String remarkes = "";// 数据库表注释
    	private static LinkedList<Map> resultCol = null;// 列信息
    	private static boolean utilPackage = false; // 是否需要导入包java.util.*
    	private static boolean sqlPackage = false; // 是否需要导入包java.sql.*
    	private static Connection connection = null;
    	private static ResultSet resultSet = null;
    
    	public GenEntityTable() {
    		super();
    	}
    
    	public GenEntityTable(final String driver, final String url, final String name, final String pass) {
    		try {
    			Properties props = new Properties();
    			props.setProperty("user", name);
    			props.setProperty("password", pass);
    			props.setProperty("remarks", "true"); // 设置可以获取remarks信息
    			props.setProperty("useInformationSchema", "true");// 设置可以获取tables remarks信息
    
    			// 创建连接
    			Class.forName(driver);
    			// getConnection = DriverManager.getConnection(URL, NAME, PASS);
    			connection = DriverManager.getConnection(url, props);
    			System.out.println("数据库连接成功");
    		} catch (ClassNotFoundException | SQLException e) {
    			System.out.println("数据库驱动加载或连接异常!");
    			e.printStackTrace();
    		}
    	}
    
    	/**
    	 * <p>Title: 读取配置文件连接数据库</p>
    	 * <p>Description: </p>
    	 * 
    	 * @author H.Yang
    	 * @date 2018年3月12日
    	 * 
    	 */
    	public static void init() {
    		try {
    			Properties properties = new Properties();
    			InputStream in = GenEntityTable.class.getClassLoader().getResourceAsStream(PROPERTIES_NAME);
    			properties.load(in);
    
    			Properties props = new Properties();
    			props.setProperty("user", properties.getProperty("db.master.user"));
    			props.setProperty("password", properties.getProperty("db.master.password"));
    			props.setProperty("remarks", "true"); // 设置可以获取remarks信息
    			props.setProperty("useInformationSchema", "true");// 设置可以获取tables remarks信息
    
    			// 创建连接
    			Class.forName(properties.getProperty("db.master.driver"));
    			connection = DriverManager.getConnection(properties.getProperty("db.master.url"), props);
    			System.out.println("数据库连接成功");
    			in.close();
    		} catch (FileNotFoundException e) {
    			e.printStackTrace();
    		} catch (IOException e) {
    			e.printStackTrace();
    		} catch (SQLException e) {
    			e.printStackTrace();
    		} catch (ClassNotFoundException e) {
    			e.printStackTrace();
    		}
    
    	}
    
    	/**
    	 * <p>Title: 获取指定表的基本信息:字段名、字段类型、字段注释</p>
    	 * <p>Description: 自带关闭连接</p>
    	 * 
    	 * @author H.Yang
    	 * @date 2018年3月12日
    	 * 
    	 */
    	private void startTable() {
    		try {
    			resultCol = new LinkedList<>();
    			Map<String, Object> map = null;
    			resultSet = connection.getMetaData().getTables(null, "%", tableName, new String[] { "TABLE" });
    			while (resultSet.next()) {
    				remarkes = resultSet.getString("REMARKS");
    
    				ResultSet rs = connection.getMetaData().getColumns(null, "%", resultSet.getString("TABLE_NAME").toUpperCase(), "%");
    				while (rs.next()) {
    					map = new HashMap<>();
    					map.put("columnName", rs.getString("COLUMN_NAME"));
    					map.put("remarks", rs.getString("REMARKS"));
    					map.put("dbType", rs.getString("TYPE_NAME"));
    					map.put("valueType", sqlType2JavaType(rs.getString("TYPE_NAME")));
    
    					if (rs.getString("TYPE_NAME").equalsIgnoreCase("datetime")) {
    						utilPackage = true;
    					}
    					if (rs.getString("TYPE_NAME").equalsIgnoreCase("image") || rs.getString("TYPE_NAME").equalsIgnoreCase("text")) {
    						sqlPackage = true;
    					}
    					resultCol.add(map);
    				}
    				if (rs != null) {
    					rs.close();
    				}
    			}
    
    			// 在内存中生成代码
    			String content = parse(tableName);
    			// 写入到文件中
    			File directory = new File("");
    			String outputPath = directory.getAbsolutePath() + "/src/main/java/" + PACKAGE_OUT_PATH.replace(".", "/") + "/"
    					+ initcap(tableName) + ".java";
    			System.out.println("写出的路径:" + outputPath);
    			// 创建文件
    			File file = new File(outputPath);
    			if (!file.exists()) {
    				file.createNewFile();
    			}
    			// 写出到硬盘
    			FileWriter fw = new FileWriter(file);
    			PrintWriter pw = new PrintWriter(fw);
    			pw.println(content);
    			pw.flush();
    			pw.close();
    		} catch (SQLException | IOException e) {
    			e.printStackTrace();
    		} finally {
    			this.close();
    		}
    	}
    
    	/**
    	 * <p>Title: 获取当前是数据库下的所有表的基本信息:字段名、字段类型、字段注释</p>
    	 * <p>Description: </p>
    	 * 
    	 * @author H.Yang
    	 * @date 2018年3月13日
    	 * 
    	 */
    	private void startMultitermTable() {
    		try {
    			Map<String, Object> map = null;
    			resultSet = connection.getMetaData().getTables(null, "%", null, new String[] { "TABLE" });
    			while (resultSet.next()) {
    				resultCol = new LinkedList<>();
    				tableName = resultSet.getString("TABLE_NAME");
    				remarkes = resultSet.getString("REMARKS");
    				ResultSet rs = connection.getMetaData().getColumns(null, "%", tableName.toUpperCase(), "%");
    				while (rs.next()) {
    					map = new HashMap<>();
    					map.put("columnName", rs.getString("COLUMN_NAME"));
    					map.put("remarks", rs.getString("REMARKS"));
    					map.put("dbType", rs.getString("TYPE_NAME"));
    					map.put("valueType", sqlType2JavaType(rs.getString("TYPE_NAME")));
    
    					if (rs.getString("TYPE_NAME").equalsIgnoreCase("datetime")) {
    						utilPackage = true;
    					}
    					if (rs.getString("TYPE_NAME").equalsIgnoreCase("image") || rs.getString("TYPE_NAME").equalsIgnoreCase("text")) {
    						sqlPackage = true;
    					}
    					resultCol.add(map);
    				}
    				if (rs != null) {
    					rs.close();
    				}
    
    				// 在内存中生成代码
    				String content = parse(transVar(tableName));
    				// 写入到文件中
    				File directory = new File("");
    				String outputPath = directory.getAbsolutePath() + "/src/main/java/" + PACKAGE_OUT_PATH.replace(".", "/") + "/"
    						+ transVar(tableName) + ".java";
    				System.out.println("写出的路径:" + outputPath);
    				// 创建文件
    				File file = new File(outputPath);
    				if (!file.exists()) {
    					file.createNewFile();
    				}
    				// 写出到硬盘
    				FileWriter fw = new FileWriter(file);
    				PrintWriter pw = new PrintWriter(fw);
    				pw.println(content);
    				pw.flush();
    				pw.close();
    			}
    
    		} catch (SQLException e) {
    			e.printStackTrace();
    		} catch (IOException e) {
    			e.printStackTrace();
    		} finally {
    			this.close();
    		}
    	}
    
    	/**
    	 * <p>Title: 关闭数据库连接</p>
    	 * <p>Description: </p>
    	 * 
    	 * @author H.Yang
    	 * @date 2018年3月12日
    	 * 
    	 */
    	private static void close() {
    		try {
    			if (resultSet != null) {
    				resultSet.close();
    			}
    			if (connection != null) {
    				connection.close();
    			}
    			System.out.println("数据库连接关闭");
    		} catch (SQLException e) {
    			e.printStackTrace();
    		}
    	}
    
    	/** 
    	 * 功能:生成实体类主体代码 
    	 * @param colNames 
    	 * @param colTypes 
    	 * @param colSizes 
    	 * @return 
    	 */
    	private String parse(String tablename) {
    		StringBuffer sb = new StringBuffer();
    		sb.append("package " + PACKAGE_OUT_PATH + ";\r\n");
    		sb.append("\r\n");
    		// 判断是否导入工具包
    		if (utilPackage) {
    			sb.append("import java.util.Date;\r\n");
    		}
    		if (sqlPackage) {
    			sb.append("import java.sql.*;\r\n");
    		}
    		// 注释部分
    		sb.append("\r\n");
    		sb.append("/**\r\n");
    		sb.append(" * <p>Title: " + remarkes + "</p>\r\n");
    		sb.append(" * <p>Description: </p>\r\n");
    		sb.append(" * \r\n");
    		sb.append(" * @author " + AUTHOR_NAME + "\r\n");
    		sb.append(" * @QQ 1033542070\r\n");
    		sb.append(" * \r\n");
    		sb.append(" * @date " + new SimpleDateFormat("yyyy-MM-dd").format(new Date()) + "\r\n");
    		sb.append(" */ \r\n");
    		// 实体部分
    		sb.append("public class " + tablename + "{\r\n");
    		processAllAttrs(sb);// 属性
    		processAllMethod(sb);// get set方法
    		sb.append("}");
    
    		return sb.toString();
    	}
    
    	/**
    	 * <p>Title: 生成所有属性 </p>
    	 * <p>Description: </p>
    	 * 
    	 * @author H.Yang
    	 * @date 2018年3月12日
    	 * 
    	 * @param sb
    	 */
    	private void processAllAttrs(StringBuffer sb) {
    		// 列名集合
    		for (Map<String, String> mapAttr : resultCol) {
    			if (StringUtils.isNotBlank(mapAttr.get("remarks"))) {
    				sb.append("\t// " + mapAttr.get("remarks") + "\r\n");
    			}
    			sb.append("\tprivate " + mapAttr.get("valueType") + " " + defineVar(mapAttr.get("columnName")) + ";\r\n");
    		}
    	}
    
    	/**
    	 * <p>Title: 生成所有方法 </p>
    	 * <p>Description: </p>
    	 * 
    	 * @author H.Yang
    	 * @date 2018年3月12日
    	 * 
    	 * @param sb
    	 */
    	private void processAllMethod(StringBuffer sb) {
    
    		for (Map<String, String> mapMethod : resultCol) {
    			// SET
    			sb.append("\r\n");
    			if (StringUtils.isNotBlank(mapMethod.get("remarks"))) {
    				sb.append("\t/**\r\n");
    				sb.append("\t * " + mapMethod.get("remarks") + "\r\n");
    				sb.append("\t */\r\n");
    			}
    			sb.append("\tpublic void set" + transVar(mapMethod.get("columnName")) + "(" + mapMethod.get("valueType") + " "
    					+ defineVar(mapMethod.get("columnName")) + ") {\r\n");
    			sb.append("\t\tthis." + defineVar(mapMethod.get("columnName")) + " = " + defineVar(mapMethod.get("columnName")) + ";\r\n");
    			sb.append("\t}\r\n");
    
    			// GET
    			sb.append("\r\n");
    			if (StringUtils.isNotBlank(mapMethod.get("remarks"))) {
    				sb.append("\t/**\r\n");
    				sb.append("\t * " + mapMethod.get("remarks") + "\r\n");
    				sb.append("\t */\r\n");
    			}
    			sb.append("\tpublic " + mapMethod.get("valueType") + " get" + initcap(transVar(mapMethod.get("columnName"))) + "() {\r\n");
    			sb.append("\t\treturn " + defineVar(mapMethod.get("columnName")) + ";\r\n");
    			sb.append("\t}\r\n");
    		}
    	}
    
    	/**
    	 * <p>Title: 将输入字符串的首字母改成大写</p>
    	 * <p>Description: </p>
    	 * 
    	 * @author H.Yang
    	 * @date 2018年3月12日
    	 * 
    	 * @param str
    	 * @return
    	 */
    	private String initcap(String str) {
    		char[] ch = str.toCharArray();
    		if (ch[0] >= 'a' && ch[0] <= 'z') {
    			ch[0] = (char) (ch[0] - 32);
    		}
    		return new String(ch);
    	}
    
    	/**
    	 * <p>Title: 用于生成get/set方法时  </p>
    	 * <p>Description: 第一个字母大写,“_”后面一个字母大写,并去掉“_”</p>
    	 * 
    	 * @author H.Yang
    	 * @date 2018年3月12日
    	 * 
    	 * @param str
    	 * @return
    	 */
    	private String transVar(String str) {
    		StringBuffer sb = new StringBuffer(str.toLowerCase());
    		String sign = "_";
    		int index = 0;
    		while ((index = sb.indexOf(sign, index)) != -1) {
    			sb.replace(index, (index + sign.length()), "");
    
    			char[] ch = new String(sb).toCharArray();
    			if (ch[0] >= 'a' && ch[0] <= 'z') {
    				ch[0] = (char) (ch[0] - 32);
    			}
    			if (index != 0 && index != ch.length) {
    				ch[index] = (char) (ch[index] - 32);
    			}
    			sb = new StringBuffer(new String(ch));
    			index = index + sign.length();
    		}
    		return sb.toString();
    	}
    
    	/**
    	 * <p>Title: 用于定义变量名  </p>
    	 * <p>Description: 首字母小写,“_”后面一个字母大写,并去掉“_”</p>
    	 * 
    	 * @author H.Yang
    	 * @date 2018年3月12日
    	 * 
    	 * @param str
    	 * @return
    	 */
    	private String defineVar(String str) {
    		StringBuffer sb = new StringBuffer(str.toLowerCase());
    		String sign = "_";
    		int index = 0;
    		while ((index = sb.indexOf(sign, index)) != -1) {
    			sb.replace(index, (index + sign.length()), "");
    			char[] ch = new String(sb).toCharArray();
    			if (ch[0] >= 'a' && ch[0] <= 'z' && index == 0) {
    				ch[0] = (char) (ch[0] - 32);
    			}
    			if (index != 0 && index != ch.length) {
    				ch[index] = (char) (ch[index] - 32);
    			}
    			sb = new StringBuffer(new String(ch));
    			index = index + sign.length();
    		}
    		return sb.toString();
    	}
    
    	/**
    	 * <p>Title: 获得列的数据类型 </p>
    	 * <p>Description: </p>
    	 * 
    	 * @author H.Yang
    	 * @date 2018年3月12日
    	 * 
    	 * @param sqlType
    	 * @return
    	 */
    	private String sqlType2JavaType(String sqlType) {
    		if (sqlType.equalsIgnoreCase("bit")) {
    			return "boolean";
    		} else if (sqlType.equalsIgnoreCase("tinyint")) {
    			return "byte";
    		} else if (sqlType.equalsIgnoreCase("smallint")) {
    			return "short";
    		} else if (sqlType.equalsIgnoreCase("int")) {
    			return "int";
    		} else if (sqlType.equalsIgnoreCase("bigint unsigned")) {
    			return "long";
    		} else if (sqlType.equalsIgnoreCase("float")) {
    			return "float";
    		} else if (sqlType.equalsIgnoreCase("decimal") || sqlType.equalsIgnoreCase("numeric") || sqlType.equalsIgnoreCase("real")
    				|| sqlType.equalsIgnoreCase("money") || sqlType.equalsIgnoreCase("smallmoney")) {
    			return "double";
    		} else if (sqlType.equalsIgnoreCase("varchar") || sqlType.equalsIgnoreCase("char") || sqlType.equalsIgnoreCase("nvarchar")
    				|| sqlType.equalsIgnoreCase("nchar") || sqlType.equalsIgnoreCase("text")) {
    			return "String";
    		} else if (sqlType.equalsIgnoreCase("datetime")) {
    			return "Date";
    		} else if (sqlType.equalsIgnoreCase("image")) {
    			return "Blod";
    		}
    
    		return null;
    	}
    
    	public static void main(String[] args) {
    
    		// GenEntityTable entity = new GenEntityTable("com.mysql.jdbc.Driver",
    		// "jdbc:mysql://localhost:3306/springwind?useUnicode=true&characterEncoding=utf-8", "root", "admini");
    		GenEntityTable entity = new GenEntityTable();
    		entity.init();
    		entity.startMultitermTable();
    		// entity.startTable();
    
    	}
    }

     

    关于DatabaseMetaData的用法 

    展开全文
  • 数据库表映射与java类映射处理

    万次阅读 2018-08-16 23:11:24
    数据库表映射与java类映射处理 1、数据库表与简单java类的映射处理 依据数据库表中的信息设计简单的java类,其实利用了上次课学习java,类间关联以及自身关联和合成设计模式实现。以下通过案例讲解数据库表与...

    数据库表的映射与java类映射处理

    1、数据库表与简单java类的映射处理

    依据数据库表中的信息设计简单的java类,其实利用了上次课学习java,类间关联以及自身关联和合成设计模式实现。以下通过案例讲解数据库表与java类的的映射处理

    (1)、数据表=类的定义

    (2)、数据库表的字段=类的属性

    (3)、数据库一条记录=类的一个实例化

    (4)、数据库多条记录=对象数组

    (5)、外键关联=类的引用关联

    实现:

    • 一个部门有多个雇员(类间关联)
    • 一个雇员属于一个部门(类间关联)
    • 一个雇员有一个领导(自身关联)

    package day01;

     

    import org.omg.CosNaming.NamingContextExtPackage.StringNameHelper;

     

    /*

     

    * 创建时间:2018年7月7日 上午1:00:24

     

    * 项目名称:studyJava

     

    * @author 飞鱼

     

    * @version 1.0

     

    * @since JDK 1.8.0_151

     

    * 文件名称:javaDamo.java

     

    * 类说明: 数据库表的映射处理

     

    */

     

    class emp{

    private Long eid; //员工ID

    private String ename; //员工姓名

    private String ejop; //员工职业

    private dep dep; // 员工所属部门

    private emp emp;//领导人

    //设置setter 和getter方法

    public dep getDep() {

    return dep;

    }

    public void setDep(dep dep) {

    this.dep = dep;

    }

    public emp getEmp() {

    return emp;

    }

    public void setEmp(emp emp) {

    this.emp = emp;

    }

    public Long getEid() {

    return eid;

    }

    public void setEid(Long eid) {

    this.eid = eid;

    }

    public String getEname() {

    return ename;

    }

    public void setEname(String ename) {

    this.ename = ename;

    }

    public String getEjop() {

    return ejop;

    }

    public void setEjop(String ejop) {

    this.ejop = ejop;

    }

    public String getInfo() {

    return "【员工信息】员工编号="+this.getEid()+"、员工姓名="+this.getEname()+"、员工职业+"+this.getEjop();

    }

    public emp(Long eid, String ename, String ejop) {

    super();

    this.eid = eid;

    this.ename = ename;

    this.ejop = ejop;

    }

    }

     

    class dep{

    private Long did;

    private String dname;

    private emp emp [];

    public dep(Long did, String dname) {

    super();

    this.did = did;

    this.dname = dname;

    }

    //设置setter 和getter方法

    public emp[] getEmp() {

    return emp;

    }

    public void setEmp(emp[] emp) {

    this.emp = emp;

    }

    public Long getDid() {

    return did;

    }

    public void setDid(Long did) {

    this.did = did;

    }

    public String getDname() {

    return dname;

    }

    public void setDname(String dname) {

    this.dname = dname;

    }

    public String getInfo() {

    return "【部门信息】部门编号="+this.getDname()+"、部门名称="+this.getDname();

    }

    }

     

    public class javaDamo {

    public static void main(String[] args) {

    emp empA=new emp(10001L, "王五", "普通员工");

    emp empB=new emp(10002L, "王四", "普通员工");

    emp empC=new emp(10003L, "王三", "管理层员工");

    dep depA=new dep(10001L, "财务部");

    dep depB=new dep(10002L, "人事部");

    //设置员工领导人

    empA.setEmp(empC);

    empB.setEmp(empC);

    //设置员工部门

    empA.setDep(depA);

    empB.setDep(depB);

    empC.setDep(depB);

    //部门设置员工

    depA.setEmp(new emp[] {empA});

    depB.setEmp(new emp [] {empB,empC});

    //输出信息

    System.out.println("-------------通过部门获取员工消息---------------");

    for (int i = 0; i < depB.getEmp().length; i++) {

    System.out.println(depB.getEmp()[i].getInfo());

    }

    System.out.println("-------------通过员工获取部门消息---------------");

    System.out.println(empA.getDep().getInfo());

    }

    }

    结果:

    -------------通过部门获取员工消息---------------

    【员工信息】员工编号=10002、员工姓名=王四、员工职业+普通员工

    【员工信息】员工编号=10003、员工姓名=王三、员工职业+管理层员工

    -------------通过员工获取部门消息---------------

    【部门信息】部门编号=财务部、部门名称=财务部

    2、数据库表的一对多映射

    描述:一个父类含有多个子类,一个子类仅有一个父类

    package day02;

     

    /*

     

    * 创建时间:2018年7月7日 上午8:43:00

     

    * 项目名称:studyJava

     

    * @author 飞鱼

     

    * @version 1.0

     

    * @since JDK 1.8.0_151

     

    * 文件名称:javaDamo1.java

     

    * 类说明: 数据库表的一对多映射

     

    */

     

    class item{

    private Long iid; //父类ID

    private String iname; //父类名称

    private subitem subitem []; //父类下的多个子类,通过对象数组设计“多”这个概念

    //无参构造方法

    public item() {

    super();

    }

    //有参构造方法

    public item(Long iid, String iname) {

    super();

    this.iid = iid;

    this.iname = iname;

    }

    //getter和setter方法

    public Long getIid() {

    return iid;

    }

    public void setIid(Long iid) {

    this.iid = iid;

    }

    public String getIname() {

    return iname;

    }

    public void setIname(String iname) {

    this.iname = iname;

    }

    public subitem[] getSubitem() {

    return subitem;

    }

     

    public void setSubitem(subitem[] subitem) {

    this.subitem = subitem;

    }

     

    public String getInfo() {

    return "【分类信息】分类ID="+this.getIid()+"分类名称="+this.getIname();

    }

    }

     

    class subitem{

    private Long sid;//子类ID

    private String sname;//子类名称

    private item item;//子类所属父类

    //无参构造方法

    public subitem() {

    super();

    }

    //有参构造方法

    public subitem(Long sid, String sname) {

    super();

    this.sid = sid;

    this.sname = sname;

    }

    //setter和getter方法

    public Long getSid() {

    return sid;

    }

    public void setSid(Long sid) {

    this.sid = sid;

    }

    public String getSname() {

    return sname;

    }

    public void setSname(String sname) {

    this.sname = sname;

    }

     

    public item getItem() {

    return item;

    }

    public void setItem(item item) {

    this.item = item;

    }

    public String getInfo() {

    return "【子类信息】子类ID="+this.getSid()+"子类名称="+this.getSname();

    }

    }

     

    public class javaDamo1 {

    public static void main(String[] args) {

    //实例化多个子类与一个父类

    subitem subitemA=new subitem(20001L,"橘子");

    subitem subitemB=new subitem(20002L,"苹果");

    subitem subitemC=new subitem(20003L,"芒果");

    item item=new item(10001L,"水果");

    item.setSubitem(new subitem[] {subitemA,subitemB,subitemC});

    subitemA.setItem(item);

    subitemB.setItem(item);

    subitemC.setItem(item);

    System.out.println("-----------------------通过父类查看子类信息-----------------------");

    System.out.println("\t|-父类:"+item.getInfo());

    for (int i = 0; i < item.getSubitem().length; i++) {

    System.out.println("\t\t|-父类的子类信息:"+item.getSubitem()[i].getInfo());

    }

    System.out.println("-----------------------通过子类查看父类信息-----------------------");

    System.out.println("\t|-A子类信息:"+subitemA.getInfo());

    System.out.println("\t\t|-A子类的父类信息:"+subitemA.getItem().getInfo());

    }

    }

     

    结果:

    -----------------------通过父类查看子类信息-----------------------

    |-父类:【分类信息】分类ID=10001分类名称=水果

    |-父类的子类信息:【子类信息】子类ID=20001子类名称=橘子

    |-父类的子类信息:【子类信息】子类ID=20002子类名称=苹果

    |-父类的子类信息:【子类信息】子类ID=20003子类名称=芒果

    -----------------------通过子类查看父类信息-----------------------

    |-A子类信息:【子类信息】子类ID=20001子类名称=橘子

    |-A子类的父类信息:【分类信息】分类ID=10001分类名称=水果

     

    3、数据库表的多对多映射

    描述:一个用户可以访问多个商品,一个商品可以被多个用户访问

    问题:

    • 获取一个用户访问那些商品信息
    • 获取一个商品被那些用户浏览

    package day02;

     

    /*

     

    * 创建时间:2018年7月7日 上午9:03:16

     

    * 项目名称:studyJava

     

    * @author 飞鱼

     

    * @version 1.0

     

    * @since JDK 1.8.0_151

     

    * 文件名称:javaDamo2.java

     

    * 类说明: 数据库表的多对多映射

     

    */

     

    class user{

    private Long uid;//用户ID

    private String uname;//用户名

    private commodity commodity [];//对象数组表示“多”概念

    //无参构造方法

    public user() {

    super();

    }

    //有参数构造方法

    public user(Long uid, String uname) {

    super();

    this.uid = uid;

    this.uname = uname;

    }

    //setter和getter方法

    public Long getUid() {

    return uid;

    }

    public void setUid(Long uid) {

    this.uid = uid;

    }

    public String getUname() {

    return uname;

    }

    public void setUname(String uname) {

    this.uname = uname;

    }

    public commodity[] getCommodity() {

    return commodity;

    }

    public void setCommodity(commodity[] commodity) {

    this.commodity = commodity;

    }

    //获取用户信息

    public String getInfo() {

    return "【用户信息】用户ID="+this.getUid()+"、用户名="+this.getUname();

    }

    }

     

    class commodity{

    private Long cid; //商品ID

    private String cname; // 商品名称

    private Double cprice; //商品价格

    private user user[]; //浏览商品的多个用户

    //无参构造方法

    public commodity() {

    super();

    }

    //有参构造方法

    public commodity(Long cid, String cname, Double cprice) {

    super();

    this.cid = cid;

    this.cname = cname;

    this.cprice = cprice;

    }

    //setter和getter方法

    public Long getCid() {

    return cid;

    }

    public void setCid(Long cid) {

    this.cid = cid;

    }

    public String getCname() {

    return cname;

    }

    public void setCname(String cname) {

    this.cname = cname;

    }

    public Double getCprice() {

    return cprice;

    }

    public void setCprice(Double cprice) {

    this.cprice = cprice;

    }

    public user[] getUser() {

    return user;

    }

    public void setUser(user[] user) {

    this.user = user;

    }

    //获取商品信息

    public String getInfo() {

    return "【商品信息】商品ID="+this.getCid()+"、商品名称="+this.getCname()+"、商品价格="+this.getCprice();

    }

    }

     

    public class javaDamo2 {

    public static void main(String[] args) {

    //实例化商品与用户

    user userA=new user(1001L,"王五");

    user userB=new user(1002L,"王四");

    user userC=new user(1003L,"王三");

    user userD=new user(1004L,"王二");

    commodity commodityA=new commodity(1001L, "短袖", 200.0);

    commodity commodityB=new commodity(1002L, "长裤", 180.0);

    commodity commodityC=new commodity(1003L, "手机", 4200.0);

    commodity commodityD=new commodity(1004L, "耳机", 78.0);

    //一个用户浏览多个商品

    userA.setCommodity( new commodity[] {commodityA,commodityB,commodityC});

    userB.setCommodity( new commodity[] {commodityA,commodityC,commodityD});

    userC.setCommodity( new commodity[] {commodityA,commodityB,commodityC,commodityD});

    userD.setCommodity( new commodity[] {commodityA,commodityB,commodityC,commodityD});

    //一个商品被多个用户浏览

    commodityA.setUser(new user[] {userA,userB,userC,userD});

    commodityB.setUser(new user[] {userA,userC,userD});

    commodityC.setUser(new user[] {userA,userB,userC,userD});

    commodityD.setUser(new user[] {userB,userC,userD});

    //打印信息

    System.out.println("------------------一个用户浏览多个商品----------------");

    System.out.println("\t|-用户A信息"+userA.getInfo());

    for (int i = 0; i < userA.getCommodity().length; i++) {

    System.out.println("\t\t|-用户A浏览商品"+userA.getCommodity()[i].getInfo());

    }

    System.out.println("------------------一个商品被多个用户浏览----------------");

    System.out.println("\t|-商品A信息"+commodityA.getInfo());

    for (int i = 0; i < commodityA.getUser().length; i++) {

    System.out.println("\t\t|-浏览A商品的用户信息"+commodityA.getUser()[i].getInfo());

    }

    }

    }

     

    结果:

    ------------------一个用户浏览多个商品----------------

    |-用户A信息【用户信息】用户ID=1001、用户名=王五

    |-用户A浏览商品【商品信息】商品ID=1001、商品名称=短袖、商品价格=200.0

    |-用户A浏览商品【商品信息】商品ID=1002、商品名称=长裤、商品价格=180.0

    |-用户A浏览商品【商品信息】商品ID=1003、商品名称=手机、商品价格=4200.0

    ------------------一个商品被多个用户浏览----------------

    |-商品A信息【商品信息】商品ID=1001、商品名称=短袖、商品价格=200.0

    |-浏览A商品的用户信息【用户信息】用户ID=1001、用户名=王五

    |-浏览A商品的用户信息【用户信息】用户ID=1002、用户名=王四

    |-浏览A商品的用户信息【用户信息】用户ID=1003、用户名=王三

    |-浏览A商品的用户信息【用户信息】用户ID=1004、用户名=王二

     

    4、数据库表的复杂映射

     

    5、总结:

    主要通过java的引用传递以及对象数组实现数据库标的映射关系。在设计数据库表的映射类时,

    先设计去除外键后的数据库表,之后依据表与表之间的关系完善类。

    展开全文
  • django 模型到数据库表映射

    千次阅读 2018-04-20 11:51:10
    1、低版本djangodjango 数据库shell操作:1、python manage.py vaildate 验证数据结构是否有错2、python manage.py sqlall [appnames] 打印数据库结构* sql显示 CREATETABLE调用* sqlall跟sql一样从.sql文件中...
  • asp.net mvc 关系数据库表之间的映射 EntityFrameWork
  • 开发过程中经常会遇到实体类保存到数据库的需求。通常就是建好数据库映射到项目中。这个代码是从代码实体类到数据库(C#+sqlite),其他语言和数据库可用来参考
  • vs2012 SqlServer2008
  • oracle数据库表映射成实体model

    千次阅读 2018-08-24 15:14:07
    //数据库连接 private static final String URL ="jdbc:oracle:thin:@127.0.0.1:1521:ORCL"; private static final String NAME = "yang"; private static final String PASS = "1234"; private static final ...
  • 对象/关系数据库映射.

    千次阅读 2019-03-18 13:37:37
    ORM的全称是:Object Relational Mapping,即对象/关系数据库映射. 当使用一种面向对象的编程语言来进行应用开发时,从项目一开始就采用的是面向对象分析,面向对象设计,面向对象编程,但到了持久层数据库访问时,又必须...
  • 计算机工程的论文 在介绍代码自动生成技术产生的背景及其应用的基础上,研究从 UML 类图到关系型数据库表之间的映射规范和映射实现方式
  • 主要介绍了简单地把MySQL结构映射为Python中的对象的方法,用到了Python中的SQLAlchemy库,需要的朋友可以参考下
  • 学习下一节:dao包中实现对数据库的操作设计1.简要说明我们先看看数据库(在登录注册系统中,就实现了一个users,用于保存用户的账号和密码)。因此,我们的JavaBean类应该如此设计,类中的属性对应中的字段...
  • oracle 数据库关系映射

    2011-07-30 17:55:16
    关系映射.关系映射.关系映射.关系映射.关系映射.关系映射.关系映射.关系映射.关系映射.关系映射.关系映射.关系映射.关系映射.关系映射.关系映射.关系映射.关系映射.关系映射.关系映射.关系映射.关系映射.关系映射.
  • 数据库设计——实体类与映射

    千次阅读 2020-09-08 21:30:46
    映射 E-R图 (Entity-Relationship),实体关系映射图 它的核心就是映射 (mapping): 1.实体名,映射成表名 2.属性,映射成列名 3.对象标示符,映射成主键约束 4.实体关系,映射成表之间的关系 (外键约束) 映射举例 ...
  • 1、默认:采用驼峰映射规则,例如MyUserTable 对应的数据库表为 my_user_table ; TEMyUserTable 对应表名为t_e_my_user_table; 2、注解@TableName 在类名上方添加@TableName("my_user_table") ...
  • 1、三种映射关系 /* 1:1 任选一个当作主键,另一个当作外键 并且外键列必须唯一 */ drop table if exists husband; drop table if exists wife; create table wife( id ...
  • spring映射数据库的命名规则小总

    千次阅读 2017-06-07 14:27:02
    本次我总结的是spring+mysql利用hibernate注解进行实体映射时候的一些命名规则: 1. mysql在数据库建表的时候不区分大小写,也就是对大小写不敏感; SELECT s.* FROM s_union_interfacetemplate s = select s.*...
  • 建立实体类和数据库映射(注解)

    千次阅读 2019-06-11 16:31:40
    1.建立实体类和数据库映射 @Select("select * from user") @Results(id = "resultMap",value = { @Result(id = true,property = "userId",column ="id"), @Result(property = "userName",column...
  • -------想要实体类与字段不与数据库表映射可以使用SpringDataJPA的注解 @Transient @Transient private Date time; 当我们给这个属性添加get方法时,@Transient注解会失效,仍然会报数据库字段映射不到的错误。...
  • 使用mybatis-plus忽略映射字段时可以在实体类属性上使用以下注解: @TableField(exist=false):表示该属性不为数据库表字段,但又是必须使用的。 @TableField(exist= true):表示该属性为数据库表字段。 ...
  • 一、绑定数据源 ... DataSource ->...右键你要生成 Model 的 -> Scripted Extentions -> Generate POJOs.groovy,选择你要将生成类存放的路径即可。 三、生成效果 package com.sample; public...
  • 对象/关系数据库映射(ORM)

    万次阅读 多人点赞 2018-04-12 22:31:44
    ORM的全称是:Object Relational Mapping,即对象/关系数据库映射.当使用一种面向对象的编程语言来进行应用开发时,从项目一开始就采用的是面向对象分析,面向对象设计,面向对象编程,但到了持久层数据库访问时,又必须...
  • 对象关系映射(Object Relational Mapping,简称ORM)是通过使用描述对象和数据库之间映射的元数据,将面向对象语言程序中的对象自动持久化到关系数据库中。本质上就是将数据从一种形式转换到另外一种形式。 这也...
  • 通用mapper数据库映射

    千次阅读 2018-07-14 10:30:03
    数据库映射 通用 Mapper 中,默认情况下是将实体类字段按照驼峰转下划线形式的表名列名进行转换。 例如 实体类的 userName 可以映射到的 user_name 上。 如果想要修改默认的转换方式,可以在后续的配置中,...
  • 第一步,连接数据库 第二步,选中多个,和生成目录,单击即可 其实是基于,先自动生成 .groovy文件,再根据文件配置,生成你想要的映射Model,.groovy文件可修改 import com.intellij.database.model.DasTable ...
  • Hibernate的核心功能是...本文就主要讲解Hibernate的映射文件的映射机制,但本文讲解的重点在于通过Hibernate如何配置实体类到数据库表映射,至于数据库表(或实体类)之间的各种关联关系的映射会在后面的文章中讲到

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 402,389
精华内容 160,955
关键字:

数据库映射表作用