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

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

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

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

个人理解：如果有需要相关联的属性，不要急着将其封装，因为如果是单向联系的属性并不需要进行封装，只要定义getter、setter方法就可以了。这样就可以在实例化以后通过getter、setter方法建立联系。

数据表与简单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、数据库表的一对多映射

描述：一个父类含有多个子类，一个子类仅有一个父类

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、数据库表的多对多映射

描述：一个用户可以访问多个商品，一个商品可以被多个用户访问

问题：

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

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的引用传递以及对象数组实现数据库标的映射关系。在设计数据库表的映射类时，

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