4.2 方法测试

骑猪看日落 2022-06-01 01:26 117阅读 0赞

完整目录结构：

![Center][]

代码：

持久化对象News.java

package com.hibernate;
    
    import java.util.Date;
    
    public class News {
    
    	private Integer id;
    	private String title;
    	private String author;
    	private Date date;
    	public Integer getId() {
    		return id;
    	}
    	public void setId(Integer id) {
    		this.id = id;
    	}
    	public String getTitle() {
    		return title;
    	}
    	public void setTitle(String title) {
    		this.title = title;
    	}
    	public String getAuthor() {
    		return author;
    	}
    	public void setAuthor(String author) {
    		this.author = author;
    	}
    	public Date getDate() {
    		return date;
    	}
    	public void setDate(Date date) {
    		this.date = date;
    	}
    	public News(String title, String author, Date date) {
    		super();
    		this.title = title;
    		this.author = author;
    		this.date = date;
    	}
    	public News() {}
    	@Override
    	public String toString() {
    		return "News [id=" + id + ", title=" + title + ", author=" + author + ", date=" + date + "]";
    	}
    }

News.hbm.xml

<?xml version="1.0"?>
    <!DOCTYPE hibernate-mapping PUBLIC
            "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
            "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
     
    <hibernate-mapping package="com.hibernate">
        <class name="News" table="news2">
            <id name="id" column="id" >
                <generator class="native"></generator>
            </id>
         		<property name="title"></property>
         		<property name="author"></property>
         		<property name="date"></property>
        </class>
         
    </hibernate-mapping>

hibernate.cfg.xml

<?xml version='1.0' encoding='utf-8'?>
    <!DOCTYPE hibernate-configuration PUBLIC
           "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
    "http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">
     
    <hibernate-configuration>
    
    	<session-factory>
    		
    		<property name="connection.driver_class">com.mysql.jdbc.Driver</property>
    		<property name="connection.url">jdbc:mysql://localhost:3306/hibernate?characterEncoding=UTF-8</property>
    		<property name="connection.username">root</property>
    		<property name="connection.password">admin</property>
    		
    		<property name="dialect">org.hibernate.dialect.MySQLDialect</property>
    		<property name="current_session_context_class">thread</property>
    		<property name="format_sql">true</property>
    		<property name="show_sql">true</property>
    		<property name="hbm2ddl.auto">update</property>
    		
    		
    		<property name="hibernate.use_identifier_rollback">true</property>
    		
    		
    		<property name="connection.isolation">2</property>
    		
    		<mapping resource="com/hibernate/News.hbm.xml" />
    	</session-factory>
    
    </hibernate-configuration>

测试类HibernateTest.java

package com.hibernate;
    
    import java.sql.Connection;
    import java.sql.SQLException;
    import java.util.Date;
    
    import org.hibernate.Session;
    import org.hibernate.SessionFactory;
    import org.hibernate.Transaction;
    import org.hibernate.cfg.Configuration;
    import org.hibernate.jdbc.Work;
    import org.hibernate.mapping.Set;
    import org.junit.After;
    import org.junit.Before;
    import org.junit.Test;
    
    import com.hibernate.News;
     
    public class HibernateTest {
    	private SessionFactory sessionfactory;
    	private Session session;
    	private Transaction transaction;
     
    	/**先使用以下代码看能否正常运行，然后再测试各种方法
    	public static void main(String[] args) {
        	
            SessionFactory sf = new Configuration().configure().buildSessionFactory();//获取SessionFactory
     
            Session s = sf.openSession();//通过SessionFactory 获取一个Session
            s.beginTransaction();//在Session基础上开启一个事务
     
            News p = new News();
            p.setAuthor("yiguang");
            p.setTitle("tianshilikai");
            p.setDate(null);
            s.save(p);//通过调用Session的save方法把对象保存到数据库
             
            s.getTransaction().commit();//提交事务
            s.close();//关闭Session
            sf.close();//关闭SessionFactory
        	
        	}
       **/
    	
    	@Before
    	public void init() {
    		 sessionfactory=new Configuration().configure().buildSessionFactory();
    		 session= sessionfactory.openSession();//通过SessionFactory 获取一个Session
    		 transaction=session.beginTransaction();
    		
    	}
    	
    	@After
    	public void destroy() {
    		transaction.commit();
    		session.close();
    		sessionfactory.close();
    		
    	}
    	
    	/*
    	 * save()方法
    	 * 1.使一个临时对象成为一个持久化对象
    	 * 2.为对象分配ID
    	 * 3.在flush缓存时会发送一条insert语句
    	 * 4.在save方法前设置ID是无效的
    	 * 5.在save方法后是不能修改ID的。因为持久化对象的ID是不能被修改的，它是独特的
    	 */
    	@Test
    	public void testSave() {
    		News new1=new News();
    		new1.setTitle("BB");
    		new1.setAuthor("bb");
    		new1.setDate(new Date());
    		new1.setId(200);//在save方法前设置ID是无效的，不会抛出异常
    		
    		System.out.println(new1);
    		
    		session.save(new1);
    		
    		System.out.println(new1);
    		new1.setId(201);//会抛出一个异常，持久化对象不能修改ID,不会执行insert操作
    		
    	}
    	
    	/*
    	 * persist()方法，也会执行insert操作
    	 * 
    	 * 和save方法区别：
    	 * 在调用presist()方法前，若对象有ID了，则不会执行insert操作，会抛出异常，而save()方法不会抛出异常
    	 */
    	@Test
    	public void testPersist() {
    		News new2=new News();
    		new2.setTitle("CC");
    		new2.setAuthor("cc");
    		new2.setDate(new Date());
    		new2.setId(100);//会抛出异常，不会执行insert操作
    		
    		session.persist(new2);
    		System.out.println(new2);
    	}
    	
    	/*
    	 * Get()和Load()的区别：
    	 * 1.执行get方法：会立即加载对象
    	 * 执行load方法，若不使用，则不会立即执行查询操作，而返回一个代理对象
    	 * 
    	 * get是立即检索，load是延迟检索。
    	 * 
    	 * 2.若数据表中没有对应的记录，Session没有关闭，同时需要使用对象时
    	 * get返回null
    	 * load需要不适用该对象的任何属性，则不抛出异常；如果初始化该对象，则会抛出异常
    	 * 
    	 * 3.load方法可能会抛出lazyInitializationException异常(懒加载异常）：在需要初始化对象之前已经关闭了Session
    	 * 在get方法中:
    	 * session.close();
    	 * System.out.println(new3);//会打印结果，已经缓存了
    	 * 
    	 * 在load方法中:
    	 * session.close();
    	 * System.out.println(new4);//会抛出异常，因为代理对象已经关闭了
    	 */
    	@Test
    	public void testGet() {
    		News new3=(News) session.get(News.class, 1);
    		//News new5=(News) session.get(News.class, 10);//数据库没有第10条记录，返回null，不会抛出异常
    		System.out.println(new3);
    	}
    	
    	@Test
    	public void testLoad() {
    		News new4=(News) session.load(News.class, 1);
    		//News new6=(News) session.load(News.class, 10);//数据库没有第10条记录，直接抛出异常
    		System.out.println(new4.getClass().getName());
    		System.out.println(new4);//也会和get()方法一样发送一条select语句。
    	}
     	
    	/*
    	 * update:
    	 * 1.若更新一个持久化对象，不需要显示的调用update()方法，因为在调用Transaction的commit()方法时，会先执行session的flush方法。
    	 * 		News new5=(News) session.get(News.class,3);
    	 * 		new5.setAuthor("haowenjie");//不需要update方法就可以修改
    	 * 2.更新一个游离对象时，需要显示的调用update,可以把一个游离对象变为持久化对象。
    	 * 
    	 * 需要注意:
    	 * 1.无论要更新的游离对象与数据库的记录是否一致，都会发送update语句
    	 * 		如何能让update方法不再盲目的触发update语句呢？在.hbm.xml文件的class节点设置select-before-update=true（默认为false）,但通常不需要设置该属性。
    	 * 
    	 * 2.若数据表中没有对应的记录，但还调用了update方法，会抛出异常
    	 * 3.当update（）方法关联一个游离对象时，如果在Session的缓存中已经存在相同OID的持久化对象，会抛出异常.因为在Session缓存中，不鞥有两个OID相同的对象。
    	 */
    	@Test
    	public void testUpdate() {
    		News new5=(News) session.get(News.class,3);
    		transaction.commit();
    		session.close();
    		
    	//	new5.setId(100);//2.若数据表中没有对应的记录，但还调用了update方法，会抛出异常
    		
    		 session= sessionfactory.openSession();
    		 transaction=session.beginTransaction();
    		 
    	//	new5.setAuthor("yiguang");
    		News new6=(News) session.get(News.class, 3);
    		session.update(new5);	
    		
    	}
    	
    	/*
    	 * 注意:
    	 * 1.若OID不为null,但是数据表中还没有为之对应的记录，则会抛出异常
    	 * 2.了解：OID值等于id的 unsave-value 属性值的对象，也被认为是一个游离对象。（在News.hbm.xml文件中修改
    	 *    <id name="id" column="id" unsaved-value="20">与new7.setId(20)两者的值相同，
    	 *    则其对象也为有利对象，那么可以实现SaveOrUpdate()方法中的save方法。
    	 */
    	@Test
    	public void testSaveOrUpdate() {
    		News new7=new News("FF","ff",new Date());
    	//	new7.setId(3);		//会执行update操作，因为数据表中有和其对应的记录
    	//	new7.setId(20);		//1.OID不为null，数据库还没有和其对应的记录，会抛出异常
    		session.saveOrUpdate(new7);		//会执行save()操作，因为OID为空
    	}
        
    	/*
    	 * delete:
    	 * 1.执行删除操作，只要OID和数据可中的一条记录对应，就会准备执行delete操作。
    	 * 		News new8=new News();
    	 *		new8.setId(4);//有对对应的记录
    	 *		session.delete(new8);
    	 * 若OID没有对应的记录，则会抛出异常
    	 * 
    	 * 2.可以通过设置hibernate。cfg.xml配置文件hibernate.use_identifier_rollback为true,使删除对象后，使其OID置为null;
    	 * 若不置为空，则还可以执行System.out.println(new9)打印等其他操作，因为delete()不是立即执行，是计划执行，在commit()方法前执行。
    	 */
    	@Test
    	public void testDelete() {
    	//	News new8=new News();
    	//	new8.setId(11);		//没有对应的记录会抛出异常
    	//	session.delete(new8);
    		
    		News new9=(News) session.get(News.class, 7);
    		session.delete(new9);
    		
    		System.out.println(new9);
    	}
    	
    	/*
    	 * evict:
    	 * 从session缓存中把指定的持久化对象移除
    	 */
    	@Test
    	public void testEvict() {
    		News new10=(News) session.get(News.class,1);
    		News new11=(News) session.get(News.class,2);
    		
    		new10.setAuthor("AA");
    		new11.setAuthor("BB");
    		 
    		session.evict(new10);//数据库中的第一条记录不会被修改，因为其修改的缓存已经被清除了
    	}
    	
    	@Test
    	public void testDoWork() {
    		session.doWork(new Work() {
    
    			@Override
    			public void execute(Connection arg0) throws SQLException {
    				System.out.println(arg0);
    				
    				//调用存储过程
    			}
    			
    		});
    	}
    }

对应的数据库：

![Center 1][]

[Center]: /images/20220601/8b5665a95fff4c0b841ad2eb1cd3d548.png
[Center 1]: /images/20220601/5ff2964586df4b029f864f7ed139cdb9.png