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

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

数据库表的映射与java类映射处理相关推荐

mysql语句生成在线_在线数据库表(sql语句)生成java实体类工具
相信每个做java开发的读者,都接触过SQL建表语句,尤其是在项目开发初期,因为数据库是项目的基石. 在现代项目开发中,出现了许多ORM框架,通过简单的实体映射,即可实现与数据库的交互,然而我们最初设 ...
6、数据库表的关系、Java对象的关系、关联查询（一对多）、延迟加载访问
文章目录关联查询.多表数据库表关系 Java对象之间的关系前提条件一对多单向关联延迟加载双向关联延迟加载延迟加载中传递多个参数关联查询.多表数据库表关系表->约束(主键约 ...
用程序同步mysql数据库表_初次用Java写了个数据库表同步工具
介绍 java 程序编写,真正跨平台. 传入一定的参数,即可在相同或不同的数据库间进行表的同步,包括表结构的同步及数据的同步.作业由调度工具进行调度,比如 moia,本项目旨在提供一种数据库间表同步的 ...
hibernate正向生成数据库表以及配置——Student.java
package cn.bdqn.studentInfo.entity;import java.util.HashSet; import java.util.Set;/*** 学生表的实体类* @aut ...
java开源数据库表描述,HSQLDB 【Java开源 DBMS数据库】
HSQLDB [Java开源 DBMS数据库] HSQLDB(Hypersonic SQL)是纯Java开发的关系型数据库,并提供JDBC驱动存取数据.支持ANSI-92 标准 SQL语法.而且他占的 ...
数据库JSON类型映射到java实体类中的对象——MyBatis框架
简介在使用MyBatis的过程中,会有这样的需求:POJO里有个属性是非基本数据类型,在DB存储时我们想存的是json格式的字符串,从DB拿出来时想直接映射成目标类型,也即json格式的字符串字段与 ...
hibernate正向生成数据库表以及配置——Teacher.java
package cn.bdqn.studentInfo.entity;import java.util.HashSet; import java.util.Set;/*** 老师的实体类* @auth ...
数据库表设计、数据库分层、myslq水平拆分、oracle表分区
数据库表设计数据库表结构设计方法及原则(li)数据库设计的三大范式:为了建立冗余较小.结构合理的数据库,设计数据库时必须遵循一定的规则.在关系型数据库中这种规则就称为范式.范式是符合某一种设计要求的 ...
生成pojo mysql_通过数据库表反向生成pojo类
import java.sql.Connection; import java.sql.DriverManager; import java.sql.PreparedStatement; import ...

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

数据库表的映射与java类映射处理相关推荐

最新文章

热门文章