Hibernate表中外键使用(个人笔记)

最新推荐文章于 2021-02-25 21:43:49 发布

Lee宇斌

最新推荐文章于 2021-02-25 21:43:49 发布

阅读量6.6k

点赞数 1

文章标签： hibernate 映射

本文链接：https://blog.csdn.net/qq_30258957/article/details/54410165

版权

（由于这篇文章写得杂乱无章，随便参考即可，不建议照做，仅作为本人日常记录）

1.前端部分

我们的思路是这样的：做一个登录页面（login.jsp），登录之后点击“朋友信息”（已登录页面main.jsp），就可以进入朋友信息页面进行数据修改(friend.jsp)。

1.login.jsp

   
   <form action="#" method="post">
<table>
<tr><td>用户名:</td><td><input type="text"/></td></tr>
<tr><td>密码:</td><td><input type="password"/></td></tr>
<tr><td colspan="2"><input type="submit" value="注册"/></td></tr>
</table>
</form>

2.main.jsp

   
   <body>
主页面
<br/>
<br/>
<a href="${pageContext.request.contextPath}/login.jsp">登录</a> 
<a href="${pageContext.request.contextPath}/friend.jsp">朋友页面</a> 
</body>

3.friend.jsp

   
   <form action="#" method="post">
<table>
<tr><td>姓名:</td><td><input type="text"/></td></tr>
<tr><td>电话:</td><td><input type="text"/></td></tr>
<tr><td colspan="2"><input type="submit" value="提交"/></td></tr>
</table>
</form>

2.login提交信息的实现

要把login.jsp中的表格内容提交，需要设置标签的name，name的构成是对象.属性，既然要用到对象，那么就需要新建javabean（包为model，名为User.java）,设置setter&getter方法

   
   package model;
public class User {
	private int id;   //id
	private String name;   //用户名
	private String pwd;   //用户密码
	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public String getPwd() {
		return pwd;
	}
	public void setPwd(String pwd) {
		this.pwd = pwd;
	}
}

这里用的是struts2框架，环境配置方面在前面《struts2的环境配置与简单登录功能实现》有提到，就不再赘述了。

这里设置标签的name属性

至于这个表格要提交到什么位置呢， action="${pageContext.request.contextPath}/user/check" 我们这里把它提交到user下的check

/user/check怎么定位呢，首先需要配置struts.xml

   
   <?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE struts PUBLIC
	"-//Apache Software Foundation//DTD Struts Configuration 2.3//EN"
	"http://struts.apache.org/dtds/struts-2.3.dtd">
<struts>
    <constant name="struts.devMode" value="true" />
    <package name="all" namespace="/" extends="struts-default">
	    <global-results>
		    <result name="main" >/main.jsp</result>
		</global-results>
    </package>   
    <include file="user.xml"></include>
</struts>

<include file = "user.xml" ></include>表示引入user.xml文件，这样做的好处就是便于分工开发。

配置user.xml文件内容

   
   <?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE struts PUBLIC
	"-//Apache Software Foundation//DTD Struts Configuration 2.3//EN"
	"http://struts.apache.org/dtds/struts-2.3.dtd">
<struts>
	<package name="user" namespace="/user" extends="all">
		<action name="*" class="action.UserAction" method="{1}">
			
		</action>
	</package>
</struts>

这里指到了 action.UserAction ，所以我们先把UserAction这个类写好（在action包中）

UserAction内容

   
   package model;
public class UserAction {
	private User user;
	public User getUser() {
		return user;
	}
	public void setUser(User user) {
		this.user = user;
	}
	
	//添加用户的方法
	public String add(){  
		return null;
	}
}

把javabean类写进去，设置setter&getter方法

这里的action方法为add，但是要注意返回值得为String ，而且参数列表不可以有内容，这是硬格式。（ public String 方法名 (){ ）

   
   <!DOCTYPE hibernate-configuration PUBLIC 
   "-//Hibernate/Hibernate Configuration DTD 3.0//EN" 
   "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd"> 
<hibernate-configuration> 
	<session-factory>
		<property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>  
		<property name="hibernate.connection.url">jdbc:mysql://localhost:3306/foreignTest</property>  
		<property name="hibernate.connection.username">root</property>  
		<property name="hibernate.connection.password">123456</property>  
		<property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property>  
		<property name="hibernate.show_sql">true</property>  
		<property name="hbm2ddl.auto">update</property>  
		<!--<mapping resource="model/Student.hbm.xml"/> 旧的映射方式-->	
		<mapping class="model.User"/>
	</session-factory>
</hibernate-configuration>

这里指明hibernate的映射类为 model.User 。

<property name = "hbm2ddl.auto" > update </property> 可以在数据库的表不存在的时候自己新建一个表

接下来用hibernate注解的方式，注明表的所在，id值（并且设置为自动增长）

（如果还没有往lib中导入jar包需要导入，否则会报错，还要web.xml也需要新建了）

编写测试语句，点击表格提交，观察控制台打印

要编写dao类，需要先完善hibernate的工具类：在common包下的 HibernateUtil

    
    package common;
import org.hibernate.*;
import org.hibernate.boot.registry.StandardServiceRegistryBuilder;
import org.hibernate.cfg.Configuration;
import org.hibernate.service.ServiceRegistry;
public class HibernateUtil {
	private static SessionFactory sessionFactory;
	private static SessionFactory buildSessionFactory() {
		try {
			Configuration configuration = new Configuration();
			configuration.configure("hibernate.cfg.xml");
			ServiceRegistry serviceRegistry = new StandardServiceRegistryBuilder()
					.applySettings(configuration.getProperties()).build();
			SessionFactory sessionFactory = configuration
					.buildSessionFactory(serviceRegistry);
			return sessionFactory;
		} catch (Throwable ex) {
			throw new ExceptionInInitializerError(ex);
		}
	}
	public static SessionFactory getSessionFactory() {
		if (sessionFactory == null)
			sessionFactory = buildSessionFactory();
		return sessionFactory;
	}
	public static Session openSession() {
		return getSessionFactory().openSession();
	}
}

现在编写用来向数据库插入数据的dao类：dao包下的UserDAO

   
   package dao;
import org.hibernate.Session;
import org.hibernate.Transaction;
import common.HibernateUtil;
import model.User;
public class UserDAO {
	Session session;
	//添加对象
	public void update(User user){
		session=HibernateUtil.openSession();  
		Transaction tx=session.beginTransaction();    //开始事务，存到tx
		session.saveOrUpdate(user);  //如果不存在就创建
		tx.commit();   //事务提交
		session.close();    //关闭session
	}
}

session = HibernateUtil . openSession (); 首先获取session，这里的session是用来处理连接数据库。

session . beginTransaction ();表示事务的开始（事务可以为了保证数据安全性，和数据库的可执行性，可以自动控制事务回滚，然后断开，这样子就不会影响数据，也不会锁死）

session . saveOrUpdate ( user ); 对对象进行保存或者修改操作，就是把save和modify组合成一个方法，会智能识别需求使用。

dao方法编写好之后，在action中调用dao方法

   
   	//添加用户的方法
	public String add(){  
		System.out.println("成功进入了add方法");   //测试：成功进入action的add方法
		dao.update(user);
		ActionContext.getContext().getSession().put("USER",user);
		return "main";
	}

这里用 ActionContext . getContext (). getSession (). put ( "USER" , user );获取session，然后把user对象存进USER的session中去。

因为做了 return "main" ;跳转，所以还需要注意在struts.xml中配置跳转路径。

这个时候查看数据库，如果user表中已经有数据，说明用hibernate成功往数据库写入数据。

2.friend提交信息的实现

既然ogin.jsp已经能提交信息了，那么现在让friend.jsp也可以提交信息，做法和上面基本一致。

1.新建friend的javabean

 
         
     package model;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
public class Friend {
	@Entity
	public class User {
		private int id;   //id
		private String name;   //用户名
		private String phone;
		@Id
		@GeneratedValue
		public int getId() {
			return id;
		}
		public void setId(int id) {
			this.id = id;
		}
		public String getName() {
			return name;
		}
		public void setName(String name) {
			this.name = name;
		}
		public String getPhone() {
			return phone;
		}
		public void setPhone(String phone) {
			this.phone = phone;
		}   
	}
}
 
   

     这里把注解也给写上了,注意hinbernate也要配置 
    <mapping class="model.Friend"/> 
   
2.接下来是friend.jsp页面表格提交的name属性

 
       
    <%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>朋友信息</title>
</head>
<body>
登录
<br/>
<br/>
<form action="${pageContext.request.contextPath}/friend/add" method="post">
<table>
<tr><td>姓名:</td><td><input type="text" name="friend.name"/></td></tr>
<tr><td>电话:</td><td><input type="text" name="friend.phone"/></td></tr>
<tr><td colspan="2"><input type="submit" value="提交"/></td></tr>
</table>
</form>
<br/>
<br/>
<a href="${pageContext.request.contextPath}/main.jsp">返回主页</a>
</body>
</html>
 
  
3.编写friend.xml并且在struts.xml中引入 
         
     <?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE struts PUBLIC
	"-//Apache Software Foundation//DTD Struts Configuration 2.3//EN"
	"http://struts.apache.org/dtds/struts-2.3.dtd">
<struts>
	<package name="friend" namespace="/friend" extends="all">
		<action name="*" class="action.FriendAction" method="{1}">
			
		</action>
	</package>
</struts>
 
   
 
    4.新建FriendAction 
   

 
       
    package action;
import com.opensymphony.xwork2.ActionContext;
import model.Friend;
public class FriendAction {
	private Friend friend;
	
	public Friend getFriend() {
		return friend;
	}
	public void setFriend(Friend friend) {
		this.friend = friend;
	}
	//添加用户的方法
	public String add(){  
		System.out.println("成功进入了add方法");   //测试：成功进入action的add方法
		return "main";
	}
}
 
  
5.新建FriendDAO方法 
         
     package dao;
import org.hibernate.Session;
import org.hibernate.Transaction;
import common.HibernateUtil;
import model.Friend;
public class FriendDAO {
	Session session;
	//添加对象
	public void update(Friend friend){
		session=HibernateUtil.openSession();  
		Transaction tx=session.beginTransaction();    //开始事务，存到tx
		session.saveOrUpdate(friend);  //如果不存在就创建
		tx.commit();   //事务提交
		session.close();    //关闭session
	}
}
 
   
6.FriendAction的add方法

  
  
   
       
    package action;
import javax.servlet.http.HttpSession;
import org.apache.struts2.ServletActionContext;
import com.opensymphony.xwork2.ActionContext;
import dao.FriendDAO;
import model.Friend;
import model.Student;
import model.User;
public class FriendAction {
	private Friend friend;
	FriendDAO dao=new FriendDAO();
	public Friend getFriend() {
		return friend;
	}
	public void setFriend(Friend friend) {
		this.friend = friend;
	}
	//添加用户的方法
	public String add(){  
		System.out.println("成功进入了add方法");   //测试：成功进入action的add方法
		dao.update(friend);
		HttpSession session=ServletActionContext.getRequest().getSession();
		User user=(User)session.getAttribute("USER");
		System.out.println("成功拿到session的内容:"+user.getName());  //测试：获取session的内容
		
		return "main";
	}
}
  
  
  
  
   
   到这里基本和前面是一样的，只是add方法多出了获取名为USER的session内容，如果控制台能打印出user的名字，说明获取成功。如果数据库Friend表成功写入数据，说明hibernate写入数据成功。

到这里两个表格写入到数据库的操作都完成了，下面要怎么把两个表格关联起来呢，这里用一对一的注解方式来编写外键映射。

3.外键关联
  
  
   
   要关联两个类，首先在Friend类中声明User类，设置getter&setter方法，在User类中声明Friend类，设置getter&setter方法。
除了声明属性，还有注解指向另一个表的外键。

 
   @OneToOne 
  
@JoinColumn(name="cid",unique=true)

 
  一对一映射，设置为目前这个表的外键，表中的名称为“cid”，设置唯一性约束。 
 

 
  而在Friend类中添加的注解为@OneToOne(mappedBy="Friend") ，表示映射到Friend这个外键上。 
 

     到这里映射已经配置好了，下面要测试映射的效果。 
  

在FriendAction中添加一下语句


  
  
   
   
    
    user.setFriend(friend);  //更新session的内容
   
   
   
   
    
    UserDAO udao=new UserDAO();
   
   
   
   udao.update(user);  //主要是更新cid的内容，通过session来更新
这样的话session里面的USER的friend内容也更新了（通过user），而userDAO的uid本来是空的，通过update也有了数值。
  
  
  
  
   
   现在要做的就是在首页添加一个标签，用来显示通过User获取的Friend的信息。


  
  
   
    这样当我们填好朋友的信息后返回到首页，它就会通过USER的session把friend的name属性提出来。
  
  
  
  
   
   

  
  
  
  
   
   
  
  
  
  
   
   （当我们把login页面的提交做成检查用户存在，登录功能，它就会在登录后获取到session，直接就能在main页面显示出对应朋友的姓名）