好记性不如烂笔头——数据表与简单Java类映射转换
内容导读
互联网集市收集整理的这篇技术教程文章主要介绍了好记性不如烂笔头——数据表与简单Java类映射转换，小编现在分享给大家，供广大互联网技能从业者学习和参考。文章包含12894字，纯文字阅读大概需要19分钟。
内容图文
一、数据表与简单Java类映射转换-
- 实际开发之中，往往根据数据表的结构来实现简单Java类。
- 数据表与简单Java类的基本映射关系：
- 数据实体表设计=类的定义；
- 表中的字段=类的成员属性；
- 表的外键关联=引用关联
- 表的一行记录=类的一个实例化对象；
- 表的多行记录=对象数组；
在以上对应数据表关系中可以发现有如下关联：
- 一个部门有多个雇员
- 一个雇员属于一个部门
- 一个雇员有一个领导
将以上数据表转化为简单Java类的形式，在整体的程序代码中要求可以获得如下信息：
- 根据部门信息获得以下内容：
- 一个部门的完整信息
- 一个部门之中所有雇员的完整信息
- 一个雇员对应的领导的信息
- 根据雇员信息获得以下内容：
- 一个雇员所在部门信息
- 一个雇员对应的领导信息
对于数据表与简单Java类之间的映射，最好的解决步骤：先抛开所有的关联字段不看，写出类的基本组成；而后再通过引用配置关联字段的关系。
- 先定义Dept、Emp;
- 配置所有的关联字段；
在以后的实际开发中分两个步骤实现：
- 根据表的结构关系进行对象的配置
- 根据要求通过结构获取数据
class Dept{//部门
private long deptno;
private String dname;
private String loc;
private Emp[] emps;//多个雇员信息
public Dept(long deptno,String dname,String loc){
this.deptno = deptno;
this.dname = dname;
this.loc = loc;
}
public void setEmps(Emp[] emps){
this.emps = emps;
}
public Emp[] getEmps(){
return this.emps;
}
public String getInfo(){
return "【部门信息】部门编号：" + this.deptno + "、部门名称：" +
this.dname + "、部门位置：" + this.loc;
}
//setter、getter方法和无参构造略
}
class Emp{//雇员
private long empno;
private String ename;
private String job;
private double sal;
private double comm;
private Dept dept;//所属部门
private Emp mgr;//所属领导
public Emp(long empno,String ename,String job,double sal,double comm){
this.empno = empno;
this.ename = ename;
this.job = job;
this.sal = sal;
this.comm = comm;
}
public void setDept(Dept dept){
this.dept = dept;
}
public void setMgr(Emp mgr){
this.mgr = mgr;
}
public Dept getDept(){
return this.dept;
}
public Emp getMgr(){
return this.mgr;
}
public String getInfo(){
return "【雇员信息】雇员编号：" + this.empno + "、雇员姓名：" + this.ename +
"、雇员职位：" + this.job + "、基本工资：" + this.sal + "、佣金：" + this.comm;
}
//setter、getter方法和无参构造略
}
public class ArrayDemo {
public static void main(String[] args) {
//第一步：根据关系进行类的定义
//定义出各自的实例化对象，此时并没有任何的关联定义
Dept dept = new Dept(10,"财务部","上海");
Emp empA = new Emp(7369L,"张三","办事员",800.00,0.0);
Emp empB = new Emp(7555L,"李四","管理",8000.00,0.0);
Emp empC = new Emp(7899L,"王五","总经理",12352.00,0.0);
//需要为对象进行关联的设置
empA.setDept(dept);//设置部门与雇员的关联
empB.setDept(dept);//设置部门与雇员的关联
empC.setDept(dept);//设置部门与雇员的关联
empA.setMgr(empB);//设置雇员与领导的关联，李四是张三的领导
empB.setMgr(empC);//设置雇员与领导的关联，王五是李四的领导，王五没有领导
dept.setEmps(new Emp[]{empA,empB,empC});//部门与雇员
//第二步：根据关系获取数据
System.out.println(dept.getInfo());//获得部门信息
for (int x = 0 ; x < dept.getEmps().length ; x++){
System.out.println("\t|-"+dept.getEmps()[x].getInfo());//获得雇员信息
if (dept.getEmps()[x].getMgr() != null){//王五没有领导，所以要判断
//获得雇员领导信息
System.out.println("\t\t|-"+dept.getEmps()[x].getMgr().getInfo());
}
}
System.out.println("--------------------------------------------------");
System.out.println(empB.getDept().getInfo());//根据雇员获得部门信息
System.out.println(empB.getMgr().getInfo());//根据雇员获得领导信息
/*
【部门信息】部门编号：10、部门名称：财务部、部门位置：上海
|-【雇员信息】雇员编号：7369、雇员姓名：张三、雇员职位：办事员、基本工资：800.0、佣金：0.0
|-【雇员信息】雇员编号：7555、雇员姓名：李四、雇员职位：管理、基本工资：8000.0、佣金：0.0
|-【雇员信息】雇员编号：7555、雇员姓名：李四、雇员职位：管理、基本工资：8000.0、佣金：0.0
|-【雇员信息】雇员编号：7899、雇员姓名：王五、雇员职位：总经理、基本工资：12352.0、佣金：0.0
|-【雇员信息】雇员编号：7899、雇员姓名：王五、雇员职位：总经理、基本工资：12352.0、佣金：0.0
--------------------------------------------------
【部门信息】部门编号：10、部门名称：财务部、部门位置：上海
【雇员信息】雇员编号：7899、雇员姓名：王五、雇员职位：总经理、基本工资：12352.0、佣金：0.0
*/
}
}
在以后的开发中，这种转换形式是要求熟练掌握的。
二、一对多映射
class Item{
private long iid;
private String title;
private Subitem[] subitems;//一个分类有多个子分类
public Item(long iid,String title){
this.iid = iid;
this.title = title;
}
public void setSubitems(Subitem[] subitems){
this.subitems = subitems;
}
public Subitem[] getSubitems(){
return this.subitems;
}
public String getInfo(){
return "【分类信息】iid：" + this.iid + "、title" + this.title;
}
}
class Subitem{
private long sid;
private String title;
private Item item;
public Subitem(long sid,String title){
this.sid = sid;
this.title = title;
}
public void setItem(Item item){
this.item = item;
}
public Item getItem(){
return this.item;
}
public String getInfo(){
return "【分类信息】iid：" + this.sid + "、title" + this.title;
}
}
public class ArrayDemo {
public static void main(String[] args) {
//第一步：根据结构设置对象数据
Item item = new Item(1L,"图书");
Subitem[] subitems = new Subitem[]{
new Subitem(10L,"编程类图书"),
new Subitem(10L,"图形类图书")
};
//设置关系
item.setSubitems(subitems);//一个分类下有多个子分类
for (int x =0 ; x < subitems.length ; x++){
subitems[x].setItem(item);
}
//第二步：根据要求获取数据
System.out.println(item.getInfo());
for (int x = 0 ; x < item.getSubitems().length ; x++){
System.out.println("\t|-"+item.getSubitems()[x].getInfo());
}
/*
【分类信息】iid：1、title图书
|-【分类信息】iid：10、title：编程类图书
|-【分类信息】iid：10、title：图形类图书
*/
}
}
三、多对多映射
对于此时的程序只要考虑实体表的设计即可，也就是说对于中间的访问记录信息表不要求进行转换处理。
class Member{//用户
private String mid;
private String name;
private Product[] product;//一个用户可能看过多个商品
public Member(String mid,String name){
this.mid = mid;
this.name = name;
}
public void setProduct(Product[] product){
this.product = product;
}
public Product[] getProduct(){
return this.product;
}
public String getInfo(){
return "【用户信息】mid="+this.mid+"、name："+this.name;
}
}
class Product{//商品
private long pid;
private String title;
private double price;
private Member[] members;//一个商品可能被多个用户看过
public Product(long pid,String title,double price){
this.pid = pid;
this.title = title;
this.price = price;
}
public void setMembers(Member[] members){
this.members = members;
}
public Member[] getMembers(){
return this.members;
}
public String getInfo(){
return "【商品信息】pid="+this.pid+"、title："+this.title+"、price："+this.price;
}
}
public class ArrayDemo {
public static void main(String[] args) {
//第一步：根据结构设置对象数据
Member memA = new Member("php","张三");
Member memB = new Member("java","李四");
Product proA = new Product(1L,"java图书开发",78.5);
Product proB = new Product(2L,"php图书开发",50.5);
Product proC = new Product(3L,"javaweb图书开发",100.5);
//设置关系
memA.setProduct(new Product[]{proA,proB,proC});//A用户可能看了所有三个商品
memB.setProduct(new Product[]{proA});//B用户可能只看了A商品
proA.setMembers(new Member[]{memA,memB});//A商品被A和B用户看了
proB.setMembers(new Member[]{memA});//B商品只有被A用户看了
proC.setMembers(new Member[]{memA});//C商品也只有被A用户看了
//第二步：根据要求获取数据
System.out.println("------------根据商品找到被哪些用户浏览过的这些用户的信息-------------");
System.out.println(proA.getInfo());//输出A商品信息
for (int x = 0 ; x < proA.getMembers().length ; x++){
//输出A商品被浏览的记录
System.out.println("\t|-"+proA.getMembers()[x].getInfo());
}
System.out.println("------------根据用户查看浏览的商品信息-------------");
System.out.println(memA.getInfo());//输出A用户信息
for (int x = 0 ; x < memA.getProduct().length ; x++){
System.out.println("\t|-"+memA.getProduct()[x].getInfo());
}
/*
------------根据商品找到被哪些用户浏览过的这些用户的信息-------------
【商品信息】pid=1、title：java图书开发、price：78.5
|-【用户信息】mid=php、name：张三
|-【用户信息】mid=java、name：李四
------------根据用户查看浏览的商品信息-------------
【用户信息】mid=php、name：张三
|-【商品信息】pid=1、title：java图书开发、price：78.5
|-【商品信息】pid=2、title：php图书开发、price：50.5
|-【商品信息】pid=3、title：javaweb图书开发、price：100.5
*/
}
}
四、复杂多对多映射
class Member{//用户
private String mid;
private String name;
private Role[] roles;//一个用户有多个角色
public Member(String mid,String name){
this.mid = mid;
this.name = name;
}
public void setRole(Role[] role){
this.roles = role;
}
public Role[] getRole(){
return this.roles;
}
public String getInfo(){
return "【用户信息】mid="+this.mid+"、name："+this.name;
}
}
class Role{//角色
private long rid;
private String title;
private Member[] members;//一个角色可以有多个用户
private Privilege[] privileges;//一个角色可以有多个权限
public Role(long rid,String title){
this.rid = rid;
this.title = title;
}
public void setMember(Member[] member){
this.members = member;
}
public Member[] getMember(){
return this.members;
}
public void setPrivileges(Privilege[] privileges){
this.privileges = privileges;
}
public Privilege[] getPrivileges(){
return this.privileges;
}
public String getInfo(){
return "【角色信息】rid="+this.rid+"、title："+this.title;
}
}
class Privilege{//权限
private long pid;
private String title;
private Role role;//一个权限属于一个角色
public Privilege(long pid,String title){
this.pid = pid;
this.title = title;
}
public void setRole(Role role){
this.role = role;
}
public Role getRole(){
return this.role;
}
public String getinfo(){
return "【权限信息】pid="+this.pid+"、title："+this.title;
}
}
public class ArrayDemo {
public static void main(String[] args) {
//第一步：根据结构设置对象数据
Member memA = new Member("mldn-a","张三");
Member memB = new Member("mldn-b","李四");
Role roleA = new Role(1L,"系统配置");
Role roleB = new Role(2L,"备份管理");
Role roleC = new Role(3L,"人事管理");
Privilege priA = new Privilege(1000L,"系统初始化");
Privilege priB = new Privilege(1001L,"系统还原");
Privilege priC = new Privilege(1002L,"系统环境修改");
Privilege priD = new Privilege(2000L,"备份员工数据");
Privilege priE = new Privilege(2001L,"备份部门数据");
Privilege priF = new Privilege(2002L,"备份公文数据");
Privilege priG = new Privilege(3000L,"增加员工");
Privilege priH = new Privilege(3001L,"编辑员工");
Privilege priI = new Privilege(3002L,"浏览员工");
Privilege priJ = new Privilege(3003L,"员工离职");
//设置角色与权限的关系
roleA.setPrivileges(new Privilege[]{priA,priB,priC});
roleB.setPrivileges(new Privilege[]{priD,priE,priF});
roleC.setPrivileges(new Privilege[]{priG,priH,priI,priJ});
//设置权限与角色关系
priA.setRole(roleA);
priB.setRole(roleA);
priC.setRole(roleA);
priD.setRole(roleB);
priE.setRole(roleB);
priF.setRole(roleB);
priG.setRole(roleC);
priH.setRole(roleC);
priI.setRole(roleC);
priJ.setRole(roleC);
//设置用户与角色的对应关系
memA.setRole(new Role[]{roleA,roleB});
memB.setRole(new Role[]{roleA,roleB,roleC});
roleA.setMember(new Member[]{memA,memB});
roleB.setMember(new Member[]{memA,memB});
roleC.setMember(new Member[]{memB});
//第二步：根据要求获取数据
System.out.println("---------根据用户查找信息----------");
System.out.println(memB.getInfo());//输出B用户信息
for (int x = 0 ; x < memB.getRole().length ; x++){
//输出B用户下所有角色信息
System.out.println("\t|-"+memB.getRole()[x].getInfo());
for (int y = 0 ; y < memB.getRole()[x].getPrivileges().length ; y++){
//输出B用户下每个角色对应的所有权限信息
System.out.println("\t\t|-"+memB.getRole()[x].getPrivileges()[y].getinfo());
}
}
System.out.println("---------根据角色查找信息----------");
System.out.println(roleB.getInfo());//输出角色B信息
System.out.println("\t|-浏览此角色下所有权限信息");
for (int x = 0 ; x < roleB.getPrivileges().length ; x++){
//输出角色B下所有权限信息
System.out.println("\t\t|-"+roleB.getPrivileges()[x].getinfo());
}
System.out.println("\t|-浏览此角色下所有用户信息");
for (int x = 0 ; x < roleB.getMember().length ; x++){
System.out.println("\t\t|-"+roleB.getMember()[x].getInfo());
}
System.out.println("---------根据权限查找信息----------");
System.out.println(priA.getinfo());
for (int x = 0 ; x < priA.getRole().getMember().length ; x++){
System.out.println("\t|-"+priA.getRole().getMember()[x].getInfo());
}
/*
---------根据用户查找信息----------
【用户信息】mid=mldn-b、name：李四
|-【角色信息】rid=1、title：系统配置
|-【权限信息】pid=1000、title：系统初始化
|-【权限信息】pid=1001、title：系统还原
|-【权限信息】pid=1002、title：系统环境修改
|-【角色信息】rid=2、title：备份管理
|-【权限信息】pid=2000、title：备份员工数据
|-【权限信息】pid=2001、title：备份部门数据
|-【权限信息】pid=2002、title：备份公文数据
|-【角色信息】rid=3、title：人事管理
|-【权限信息】pid=3000、title：增加员工
|-【权限信息】pid=3001、title：编辑员工
|-【权限信息】pid=3002、title：浏览员工
|-【权限信息】pid=3003、title：员工离职
---------根据角色查找信息----------
【角色信息】rid=2、title：备份管理
|-浏览此角色下所有权限信息
|-【权限信息】pid=2000、title：备份员工数据
|-【权限信息】pid=2001、title：备份部门数据
|-【权限信息】pid=2002、title：备份公文数据
|-浏览此角色下所有用户信息
|-【用户信息】mid=mldn-a、name：张三
|-【用户信息】mid=mldn-b、name：李四
---------根据权限查找信息----------
【权限信息】pid=1000、title：系统初始化
|-【用户信息】mid=mldn-a、name：张三
|-【用户信息】mid=mldn-b、name：李四
*/
}
}
内容总结
以上是互联网集市为您收集整理的好记性不如烂笔头——数据表与简单Java类映射转换全部内容，希望文章能够帮你解决好记性不如烂笔头——数据表与简单Java类映射转换所遇到的程序开发问题。 如果觉得互联网集市技术教程内容还不错，欢迎将互联网集市网站推荐给程序员好友。
内容备注
版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 gblab@vip.qq.com 举报，一经查实，本站将立刻删除。
内容手机端
扫描二维码推送至手机访问。
来源：【匿名】