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

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

  • 0
    点赞
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
为了使用Hibernate实现Java类和数据库映射,需要进行以下步骤: 1. 创建Java类,该类必须包含一个默认构造函数,并且每个属性都必须有getter和setter方法。 2. 在Java类上使用Hibernate注释,以指示Hibernate如何将该类映射数据库。可以使用注释来指定名、列名、主键、外键等信息。 3. 配置Hibernate,包括设置数据库连接、指定Hibernate所需的驱动程序、数据库方言等。 4. 使用Hibernate API创建数据访问对象(DAO),该DAO将提供CRUD(创建、读取、更新、删除)操作,可以使用Hibernate提供的现成的DAO实现或自己实现。 5. 在应用程序中使用DAO访问数据库。 下面是一个使用Hibernate实现Java类和数据库映射的示例: ``` @Entity @Table(name = "students") public class Student { @Id @GeneratedValue(strategy = GenerationType.IDENTITY) private Long id; @Column(name = "name") private String name; @Column(name = "email") private String email; // getters and setters } // DAO interface public interface StudentDao { void save(Student student); void update(Student student); void delete(Student student); List<Student> getAll(); Student getById(Long id); } // DAO implementation @Repository public class StudentDaoImpl implements StudentDao { @Autowired private SessionFactory sessionFactory; @Override public void save(Student student) { sessionFactory.getCurrentSession().save(student); } @Override public void update(Student student) { sessionFactory.getCurrentSession().update(student); } @Override public void delete(Student student) { sessionFactory.getCurrentSession().delete(student); } @Override public List<Student> getAll() { return sessionFactory.getCurrentSession() .createQuery("FROM Student", Student.class) .getResultList(); } @Override public Student getById(Long id) { return sessionFactory.getCurrentSession().get(Student.class, id); } } // usage public class Main { public static void main(String[] args) { ApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class); StudentDao studentDao = context.getBean(StudentDao.class); // create student Student student = new Student(); student.setName("John Doe"); student.setEmail("johndoe@example.com"); // save student studentDao.save(student); // update student student.setEmail("johndoe2@example.com"); studentDao.update(student); // get student by id Student retrievedStudent = studentDao.getById(student.getId()); System.out.println(retrievedStudent); // delete student studentDao.delete(retrievedStudent); } } ``` 在这个示例中,我们创建了一个名为Student的Java类,并使用Hibernate注释将其映射数据库students。我们还创建了一个StudentDao接口和其实现类StudentDaoImpl,该实现类使用Hibernate API访问数据库。最后,在Main类中,我们使用Spring容器获取StudentDao实例,并使用它执行CRUD操作。

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值