JAP中的单向一对多,单向多对一

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);

	}

}