强烈推荐一个大神的人工智能的教程：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表已经映射过来了。
 
测试
 
    在服务器上将这张映射的表修改一条数据,会发现本地库中这张映射过来的表数据同时改变了!到此基本可以确定这样远程映射表是成功了!我将代码中的数据库地址修改为我本地,执行某个接口的查询操作,成功查询回正确的结果,标明远程映射表成功!
 
 

数据表之间的关联关系分为3种:一对一,一对多,多对多.
 
一对一
 
 是将数据表垂直切分,其实是不常见的,或不常用的.也就是A表的一条记录对应B表的一条记录, 例如:一个系统必然有员工表（包含字段：EmployeeId、姓名、性别、年龄、电话、地址等），每个员工都为一个用户，所以还有张 User 表（包含字段：UserId（关联 EmployeeId）、用户名、密码、角色等），这样你会发现，整合为一张表是否不太妥当？因为，User 的记录只会在登录时用到，感觉有点违背三大范式中的“确保每列都和主键列直接关联，而不是间接关联”。
 还有种情况，这就要根据具体的业务来决定了。如果，当一张表的字段过于太多，而很多字段可能只有在某些情况下，才会使用到，这时也可以考虑使用一对一设计。
 
优点
 
 
便于管理、可提高一定的查询速度
 
 
减轻 CPU 的 IO 读写，提高存取效率。
 
 
符合数据库设计的三大范式。
 
 
符合关系性数据库的特性。
 
 
Ø 缺点
 
增加一定的复杂程度，程序中的读写难度加大。
 
一对多
 
  是最常见的设计,就是A表的一条记录,对应B表的多条记录,且A的主键作为B表的外键这主要看以哪张表为中心，以上示例以 A 表为中心，就是一对多，如果以 B 表为中心，则是多对一。举几个例子：
 
 
班级表 与 学生表，一个班级对应多个学生，或者多个学生对应一个班级。
 
 
角色表 与 用户表，一个角色对应多个用户，或者多个用户对应一个角色。
 
 
商品表 与 图片表，一个商品对应多张图片，或者多张图片对应一个商品。
 
 
多对多
 
 
Ø 多对多，在数据库中也比较常见，可以理解为是一对多和多对一的组合。要实现多对多，一般都需要有一张中间表（也叫关联表），将两张表进行关联，形成多对多的形式。例如：
 
老师表、班级表、科目表，中间表为：课程表
 
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

 
 
分享知识 传递快乐
 
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类映射处理
 
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的引用传递以及对象数组实现数据库标的映射关系。在设计数据库表的映射类时，
 
先设计去除外键后的数据库表，之后依据表与表之间的关系完善类。