package zhang.jpa.helloword;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import javax.persistence.CascadeType;
import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.EntityTransaction;
import javax.persistence.FetchType;
import javax.persistence.OneToMany;
import javax.persistence.Persistence;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
public class TestJpa {
private EntityManagerFactory entityManagerFactory = null;
private EntityManager entityManager = null;
private EntityTransaction transaction = null;
@Before
public void init() {
String persistenceUnitName = "jpa-1";
entityManagerFactory = Persistence.createEntityManagerFactory(persistenceUnitName);
entityManager = entityManagerFactory.createEntityManager();
transaction = entityManager.getTransaction();
transaction.begin();
}
@After
public void after() {
transaction.commit();
entityManager.close();
entityManagerFactory.close();
}
@Test
public void testonetomanyupdate(){
User user=entityManager.find(User.class, 4);
user.getOrderes().iterator().next().setOrderName("tomcat");
}
//默认情况下产删除的方式是将多的一方的外键列值为空,从而使外键约束没有,删除一的一方
//但是可以使用@OneToMany(fetch=FetchType.EAGER,cascade={CascadeType.REMOVE}),从而使级联一起删除
@Test
public void testonetomanydelete(){
User user=entityManager.find(User.class, 3);
entityManager.remove(user);
}
//查询的时候一的一方的时候默认使用懒加载,
//但是可以使用@OneToMany(fetch=FetchType.EAGER)注解的方式,使查询的时候,将其关联的order,使用左外连接一起查询出来
@Test
public void testonetomanyget(){
User user=entityManager.find(User.class, 1);
System.out.println(user.getUsername());
System.out.println(user.getOrderes().size());
}
//无论保存的顺序如果,都会发送三条insert语句,两条update语句
@Test
public void testonetomanysave(){
User user=new User();
user.setUsername("zhangyukang2");
user.setCreatedtime(new Date());
user.setPassword("1222122");
user.setEmail("zyk@qq.com");
user.setPhonenumber("123455555");
user.setBirthday(new Date());
Order order=new Order();
order.setOrderName("order-cc");
Order order2=new Order();
order2.setOrderName("order-dd");
//设置关联关系
user.getOrderes().add(order);
user.getOrderes().add(order2);
//保存操作
entityManager.persist(order2);
entityManager.persist(order);
entityManager.persist(user);
}
/*
@Test
public void testmanytooneupdate(){
User user = entityManager.find(User.class, 12);
user.setUsername("tomcat");
Order order=entityManager.find(Order.class, 3);
order.getUser().setUsername("java");
}
//注意不能直接删除一的一方,因为在多的一方有一的引用(外键约束)
@Test
public void testmanytoonedelete(){
User user=entityManager.find(User.class, 11);
entityManager.remove(user);
// Order order=entityManager.find(Order.class, 2);
// entityManager.remove(order);
}
//默认情况下(单向多对一),在获取多的一方的时候,会把所关联的一的一方使用左外连接一起获取
//可以在@ManyToOne(fetch=FetchType.LAZY)注解设置fetch=FetchType.LAZY,来使用懒加载,在不需要时候一的一方的属性的时候,将不会
//使用左外连接,来一起将一的一方的记录获取,注意:发生懒加载异常
@Test
public void testmanytooneget(){
Order order=entityManager.find(Order.class, 1);
System.out.println(order.getOrderName());
//System.out.println(order.getUser().getUsername());
}
// 单向多对一,在保存的时候,建议先保存一的一方,应为这样可以少发送两条sql语句
@Test
public void testmanytoone() {
User user = new User();
user.setBirthday(new Date());
user.setUsername("bbzhangyukang");
user.setCreatedtime(new Date());
user.setEmail("bbzyk3053161401@qq.com");
user.setPassword("123456");
user.setPhonenumber("11012122");
Order order1 = new Order();
order1.setOrderName("order1-bb");
Order order2 = new Order();
order2.setOrderName("order2-bb");
// 设置关联关系
order1.setUser(user);
order2.setUser(user);
// 保存
entityManager.persist(order1);
entityManager.persist(order2);
entityManager.persist(user);
}
@Test
public void testgetuser() {
User user = entityManager.getReference(User.class, 11);
System.out.println(user);
}*/
@Test
public void testsave() {
User user = new User("hang", "305316", new Date(), "zyk@qq.com", "13425222");
user.setCreatedtime(new Date());
entityManager.persist(user);
}
// (数据库对缓存发起)该方法用于是数据库中的和缓存中的记录保持一致,在事务提交的时候
//,会如果缓存中的对象发生改变,此时会向数据库发送一条select语句
@Test
public void testreflush() {
User user = entityManager.find(User.class, 11);
System.out.println(user);
entityManager.refresh(user);
user = entityManager.find(User.class, 11);
System.out.println(user);
}
// (缓存向数据库发起)该方法用于是数据库中的和缓存中的记录保持一致,在事务提交的时候
//,会如果缓存中的对象发生改变,此时会向数据库发送一条update语句
@Test
public void testflush() {
User user = entityManager.find(User.class, 11);
System.out.println(user);
user.setUsername("peter");
// 手动的调用flush方法,此时如果缓存中的对象发生变化,会发送一条sql语句
//,但是因为事务没有提交,因此数据库中的记录还没有变化 要到事务提交之后才会修改
entityManager.flush();
}
@Test
public void testget() {
List<User> resultList = entityManager.createQuery("from User").getResultList();
System.out.println(resultList);
}
// 如果传入的是一个游离对象即存在ID
// 如果entityManager,缓存存在OID的记录
// 2)如果数据库中存在OID,JPA会把游离对象的属性赋值给缓存中的对象,然后进行持久化操作(update)
@Test
public void testmerge4() {
User user = new User("bbbvvvv", "111", new Date(), "dfdasf@.com", "110");
user.setId(2);
User user2 = entityManager.merge(user);
System.out.println(user2);
}
// 如果传入的是一个游离对象即存在ID
// 如果entityManager,缓存不存在OID的记录
// 2)如果数据库中存在OID相对应记录,则会新创建一个user对象,向游离对象的属性赋值个新对象,然后进行持久化操作(update)
@Test
public void testmerge3() {
User user = new User("bbbvvvv", "111", new Date(), "dfdasf@.com", "110");
user.setId(2);
User user2 = entityManager.merge(user);
System.out.println(user2);
}
// 如果传入的是一个游离对象即存在ID
// 如果entityManager,缓存中不存在OID的记录
// 1)如果数据库中不存在OID相对应记录,则会新创建一个user对象,向游离对象的属性赋值个新对象,然后进行持久化操作(insert)
@Test
public void testmerge2() {
User user = new User("bbbvvvv", "111", new Date(), "dfdasf@.com", "110");
user.setId(100);
User user2 = entityManager.merge(user);
System.out.println(user);
System.out.println(user2);
}
// 1.如果传入的是一个临时对象
// 类似于hibernate的中的saveorupdate方法,首先会创建一个user对象,把临时对象的属相赋值到新创建的对象中,
// 然后在执行持久化操作
@Test
public void testmerge() {
User user = new User("aa", "111", new Date(), "dfdasf@.com", "110");
User user2 = entityManager.merge(user);
System.out.println(user);
System.out.println(user2);
}
@Test
public void test() {
// 创建EntityManagerFactory对象
String persistenceUnitName = "jpa-1";
Map<String, Object> map = new HashMap<>();
map.put("hibernate.show_sql", true);
EntityManagerFactory entityManagerFactory =
// Persistence.createEntityManagerFactory(persistenceUnitName);
Persistence.createEntityManagerFactory(persistenceUnitName, map);
// 创建EntityManager对象
EntityManager entityManager = entityManagerFactory.createEntityManager();
// 开启事务
EntityTransaction transaction = entityManager.getTransaction();
transaction.begin();
// 进行持久化操作
User user = new User("zhang", "305316", new Date(), "zyk@qq.com", "13425222");
entityManager.persist(user);
// 提交事务
transaction.commit();
// 关闭EntityManager
entityManager.close();
// 关闭EntityManagerFactory
entityManagerFactory.close();
}
// 该方法类似于hibernate的delete方法,注意此方法只能够移除持久化对象,而hibernate的delete实际上还可以移除游离对象
@Test
public void testremove() {
User user = entityManager.find(User.class, 1);
entityManager.remove(user);
}
// 该方法类似于hibernate的save方法,使对象由临时状态转变成持久化状态
// 和hibernate的sesssion的save方法的不同之处,如果对象存在id,则不能执行该方法,会抛出异常
@Test
public void testpersist() {
User user = new User();
user.setBirthday(new Date());
user.setUsername("justinbieber");
user.setPassword("12121");
user.setEmail("zyk@qq.com");
// user.setId(12);
user.setCreatedtime(new Date());
entityManager.persist(user);
System.out.println("id:" + user.getId());
}
// 相当于hibernate中的session的load方法
@Test
public void testreference() {
User user = entityManager.getReference(User.class, 1);
System.out.println(user.getClass().getName());
System.out.println("---------------------");
System.out.println(user);
}
// find方法类似于hibernate的get方法
@Test
public void testjpa() {
User user = entityManager.find(User.class, 1);
System.out.println("----------------------");
System.out.println(user);
}
}
JAP中的单向一对多,单向多对一
最新推荐文章于 2024-02-26 22:18:48 发布