Hibernate-Usage(basis)(hibernate基本用法)

最新推荐文章于 2022-10-08 08:00:00 发布
最新推荐文章于 2022-10-08 08:00:00 发布
阅读量864 收藏
点赞数
分类专栏： #FRAMEWORK# 文章标签： hibernate log4j
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Love_Legain/article/details/54694493
版权

hibernate基本用法

part_0:下载源码(http://download.csdn.net/detail/love_legain/9744626)

part_1:导入基础所需包(这些包都是必须的,其中log4j用户记录日志)

antlr-2.7.7.jar
cdi-api-1.1.jar
classmate-1.3.0.jar
dom4j-1.6.1.jar
el-api-2.2.jar
geronimo-jta_1.1_spec-1.1.1.jar
hibernate-commons-annotations-5.0.1.Final.jar
hibernate-core-5.2.5.Final.jar
hibernate-jpa-2.1-api-1.0.0.Final.jar
hibernate-jpamodelgen-5.2.5.Final.jar
jandex-2.0.3.Final.jar
javassist-3.20.0-GA.jar
javax.inject-1.jar
jboss-interceptors-api_1.1_spec-1.0.0.Beta1.jar
jboss-logging-3.3.0.Final.jar
jsr250-api-1.0.jar
log4j-1.2.17.jar
mysql-connector-java-5.1.7-bin.jar
slf4j-api-1.7.7.jar
slf4j-log4j12-1.7.5.jar

part_2:实体类(User)

package cn.mike.entity;

public class User {

    private int uid;
    private String username;
    private String password;

    public int getUid() {
        return uid;
    }

    public void setUid(int uid) {
        this.uid = uid;
    }

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

}

part_3:User的映射配置文件(User.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>
    <class name="cn.mike.entity.User" table="t_user">
        <id name="uid" column="uid">
            <generator class="native" />
        </id>
        <property name="username" column="username" />
        <property name="password" column="password" />
    </class>
</hibernate-mapping>

part_4:Company.java

package cn.mike.entity;

import java.util.Set;

/**
 * @author Administrator
 * @usage 用于一对多关系的练习(一个公司对应多个雇员)
 */
public class Company {

    private Integer comId;
    private String comName;
    private String comHeadquarters;
    private Set<Employee> employees;

    public Company(Integer comId, String comName, String comHeadquarters, Set<Employee> employees) {
        // 在此之前,必须保证要有无参的构造方法存在
        this.comId = comId;
        this.comName = comName;
        this.comHeadquarters = comHeadquarters;
        this.employees = employees;
    }

    public Company() {// 必须保证要有无参的构造方法
    }

    public Integer getComId() {
        return comId;
    }

    public void setComId(Integer comId) {
        this.comId = comId;
    }

    public String getComName() {
        return comName;
    }

    public void setComName(String comName) {
        this.comName = comName;
    }

    public String getComHeadquarters() {
        return comHeadquarters;
    }

    public void setComHeadquarters(String comHeadquarters) {
        this.comHeadquarters = comHeadquarters;
    }

    public Set<Employee> getEmployees() {
        return employees;
    }

    public void setEmployees(Set<Employee> employees) {
        this.employees = employees;
    }

}

part_5:Company.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>
    <class name="cn.mike.entity.Company" table="t_company">
        <id name="comId" column="comId">
            <generator class="native" />
        </id>
        <property name="comName" column="comName" />
        <property name="comHeadquarters" column="comHeadquarters" />
        <set name="employees" cascade="save-update,delete" inverse="true">
            <key column="comEmpId" />
            <one-to-many class="cn.mike.entity.Employee" />
        </set>
    </class>
</hibernate-mapping>

part_6:Employee.java

package cn.mike.entity;

/**
 * @author Administrator
 * @usage 用于一对多关系的练习(一个公司对应多个雇员)
 */
public class Employee {

    private Integer empId;
    private String empName;
    private String empGender;
    private Company company;

    public Employee() {// 必须保证要有无参的构造方法
    }

    public Employee(Integer empId, String empName, String empGender, Company company) {
        // 在此之前,必须保证要有无参的构造方法存在
        this.empId = empId;
        this.empName = empName;
        this.empGender = empGender;
        this.company = company;
    }

    public Integer getEmpId() {
        return empId;
    }

    public void setEmpId(Integer empId) {
        this.empId = empId;
    }

    public String getEmpName() {
        return empName;
    }

    public void setEmpName(String empName) {
        this.empName = empName;
    }

    public String getEmpGender() {
        return empGender;
    }

    public void setEmpGender(String empGender) {
        this.empGender = empGender;
    }

    public Company getCompany() {
        return company;
    }

    public void setCompany(Company company) {
        this.company = company;
    }

}

part_7:Employee.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>
    <class name="cn.mike.entity.Employee" table="t_emptact">
        <id name="empId" column="empId">
            <generator class="native" />
        </id>
        <property name="empName" column="empName" />
        <property name="empGender" column="empGender" />
        <many-to-one name="company" class="cn.mike.entity.Company" column="comEmpId"></many-to-one>
    </class>
</hibernate-mapping>

part_8:Course.java

package cn.mike.entity;

import java.util.Set;

/**
 * @author Administrator
 * @usage Course:课程类,用于多对对练习的类(一门课程可以被多个学生选修)
 */
public class Course {

    private Integer courseID;
    private String courseName;
    private Set<Student> students;// 选修该课程的学生

    public Course() {
    }

    public Course(Integer courseID, String courseName, Set<Student> students) {
        this.courseID = courseID;
        this.courseName = courseName;
        this.students = students;
    }

    public Integer getCourseID() {
        return courseID;
    }

    public void setCourseID(Integer courseID) {
        this.courseID = courseID;
    }

    public String getCourseName() {
        return courseName;
    }

    public void setCourseName(String courseName) {
        this.courseName = courseName;
    }

    public Set<Student> getStudents() {
        return students;
    }

    public void setStudents(Set<Student> students) {
        this.students = students;
    }

}

part_9:Course.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>
    <class name="cn.mike.entity.Course" table="COURSE">
        <id name="courseID" column="courseID">
            <generator class="native" />
        </id>
        <property name="courseName" column="courseName" />
        <set name="students" table="COURSE_STUDENT" cascade="save-update,delete">
            <!-- 在第三张表中的键名称 -->
            <key column="courseID" />
            <many-to-many class="cn.mike.entity.Student" column="stuID" />
        </set>
    </class>

</hibernate-mapping>

part_10:Student.java

package cn.mike.entity;

import java.util.Set;

/**
 * @author Administrator
 * @usage Student:学生类,用于多对对练习的类(一个学生可以选修多门课程)
 */
public class Student {

    private Integer stuID;
    private String stuName;
    private Set<Course> courses;// 该学生选修的课程

    public Student() {
    }

    public Student(Integer stuID, String stuName, Set<Course> courses) {
        this.stuID = stuID;
        this.stuName = stuName;
        this.courses = courses;
    }

    public Integer getStuID() {
        return stuID;
    }

    public void setStuID(Integer stuID) {
        this.stuID = stuID;
    }

    public String getStuName() {
        return stuName;
    }

    public void setStuName(String stuName) {
        this.stuName = stuName;
    }

    public Set<Course> getCourses() {
        return courses;
    }

    public void setCourses(Set<Course> courses) {
        this.courses = courses;
    }

}

part_11:Student.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>
    <class name="cn.mike.entity.Student" table="STUDENT">
        <id name="stuID" column="stuID">
            <generator class="native" />
        </id>
        <property name="stuName" column="stuName" />
        <set name="courses" table="COURSE_STUDENT">
            <!-- 在第三张表中的键名称 -->
            <key column="stuID" />
            <many-to-many class="cn.mike.entity.Course" column="courseID" />
        </set>
    </class>
</hibernate-mapping>

part_12:log4j.properties

log4j.rootLogger=debug, stdout, R
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.Target=System.err
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%d [%t] %-5p %c - %m%n

log4j.appender.R=org.apache.log4j.RollingFileAppender
log4j.appender.R.File=log4j.log
log4j.appender.R.MaxFileSize=100KB

log4j.appender.R.MaxBackupIndex=1
log4j.appender.R.layout=org.apache.log4j.PatternLayout
log4j.appender.R.layout.ConversionPattern=%p %t %c - %m%n

log4j.logger.com.foo=WARN

part_13: HibernateUtils.java

package cn.mike.utils;

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;

public class HibernateUtils {

    private static final Configuration cfg;
    private static final SessionFactory sessFac;

    static {
        cfg = new Configuration().configure();
        sessFac = cfg.buildSessionFactory();
    }

    public static SessionFactory getSessionFactory() {
        return sessFac;
    }

    public static Session getBoundSession() {
        return sessFac.getCurrentSession();
    }

    public static void closeSessionFactory() {
        sessFac.close();
    }

    public static void main(String[] args) {
        // System.out.println("demo's running...");
    }
}

part_14:hibernate核心配置文件(hibernate.cfg.xml)

<!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>
        <!-- 1.配置数据库信息 -->
        <property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
        <property name="hibernate.connection.url">jdbc:mysql:///hibernate</property>
        <property name="hibernate.connection.username">root</property>
        <property name="hibernate.connection.password">3713</property>

        <!-- 2.配置hibernate信息 -->
        <!-- print all generated SQL to the console -->
        <property name="hibernate.show_sql">true</property>
        <!-- format SQL in log and console -->
        <property name="hibernate.format_sql">true</property>
        <!-- update:若表不存在就新建,否则就更新 -->
        <property name="hibernate.hbm2ddl.auto">update</property>
        <!-- hibernate.dialect -->
        <property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property>
        <!-- 与本地线程绑定session -->
        <property name="hibernate.current_session_context_class">thread</property>

        <!-- 3.将映射文件放到核心配置文件中 -->
        <mapping resource="cn/mike/entity/User.hbm.xml" />
        <mapping resource="cn/mike/entity/Company.hbm.xml" />
        <mapping resource="cn/mike/entity/Employee.hbm.xml" />
        <mapping resource="cn/mike/entity/Course.hbm.xml" />
        <mapping resource="cn/mike/entity/Student.hbm.xml" />
    </session-factory>
</hibernate-configuration>

part_15:QualityTest.java(单元测试)

package cn.mike.demo;

import java.util.HashSet;
import java.util.List;
import java.util.Set;

import org.hibernate.Criteria;
import org.hibernate.SQLQuery;
import org.hibernate.Session;
import org.hibernate.Transaction;
import org.hibernate.query.Query;
import org.junit.Test;

import cn.mike.entity.Employee;
import cn.mike.entity.Student;
import cn.mike.entity.Company;
import cn.mike.entity.Course;
import cn.mike.entity.User;
import cn.mike.utils.HibernateUtils;

public class QualityTest {

    @Test
    public void testFunction() {
        // 单表操作(user)
        // testAdd();
        // testUpdate();
        // testGet();
        // testDelete();
        // testSaveOrUpdate();
        // testBoundSession();
        // testQuery();
        // testCriteria();
        // testSQLQuery();

        // 多表操作(一对多关系,一个公司对应多个雇员)
        // testCascadeSave_1();// (复杂写法)
        // testCascadeSave_2();// 简化写法
        // testCascadeDelete();// 级联删除
        // testCascadeUpdate();// 修改

        // 多表(多对多关系,多门课程对应对个学生)
        // testM2MSave();// test many-to-many save
        // testM2MDelete();// test many-to-many delete(一般不使用这种方法)
        // testM2MAdd();// test many-to-many add
        // testM2MRemove();// test many-to-many remove

    }

    private void testM2MRemove() {
        Session sess = null;
        Transaction tx = null;

        try {
            sess = HibernateUtils.getBoundSession();
            tx = sess.beginTransaction();

            // e.g.让Michelle不再选修DataStructure
            Course course = sess.get(Course.class, 1);
            Student student = sess.get(Student.class, 3);

            course.getStudents().remove(student);

            tx.commit();
        } catch (Exception e) {
            e.printStackTrace();
            tx.rollback();
        } finally {
            // sess.close();//与本地线程绑定后就不需要close了;
            HibernateUtils.closeSessionFactory();// 实际开发中不需要关闭
        }
    }

    private void testM2MAdd() {
        Session sess = null;
        Transaction tx = null;

        try {
            sess = HibernateUtils.getBoundSession();
            tx = sess.beginTransaction();

            // e.g.让Michelle选修DataStructure
            Course course = sess.get(Course.class, 1);
            Student student = sess.get(Student.class, 3);

            course.getStudents().add(student);

            tx.commit();
        } catch (Exception e) {
            e.printStackTrace();
            tx.rollback();
        } finally {
            // sess.close();//与本地线程绑定后就不需要close了;
            HibernateUtils.closeSessionFactory();// 实际开发中不需要关闭
        }
    }

    private void testM2MDelete() {// 先要配置cascade="save-update,delete"
        Session sess = null;
        Transaction tx = null;

        try {
            sess = HibernateUtils.getBoundSession();
            tx = sess.beginTransaction();

            // 删除所有选修DataStructure的学生
            sess.delete(sess.get(Course.class, 4));

            tx.commit();
        } catch (Exception e) {
            e.printStackTrace();
            tx.rollback();
        } finally {
            // sess.close();//与本地线程绑定后就不需要close了;
            HibernateUtils.closeSessionFactory();// 实际开发中不需要关闭
        }
    }

    /**
     * 多对多的级联保存操作(需要配置在主动提交的类中.e.g.save(course)那就配置在course的xml文件中)
     * 
     */
    private void testM2MSave() {
        Session sess = null;
        Transaction tx = null;

        try {
            sess = HibernateUtils.getBoundSession();
            tx = sess.beginTransaction();

            // 两门课程(数据结构<DataStructure>和算法<Algorithm>)
            Course courseDS = new Course(null, "DataStructure", null);
            Course courseAlg = new Course(null, "Algorithm", null);

            // 三个学生(Mike,Michael,Michelle)
            Student stuMike = new Student(null, "Mike", null);
            Student stuMichael = new Student(null, "Micheal", null);
            Student stuMichelle = new Student(null, "Michelle", null);

            // dsStudents:选修DataStructure的学生,algStudent:选修Algtithm的学生
            Set<Student> dsStudents = (null == courseDS.getStudents() ? new HashSet<Student>() : courseDS.getStudents());
            Set<Student> algStudents = (null == courseAlg.getStudents() ? new HashSet<Student>() : courseAlg.getStudents());

            dsStudents.add(stuMike);// Mike选修了DataStructure
            dsStudents.add(stuMichael);// Michael选修了DataStructure
            algStudents.add(stuMichael);// Michael选修了Algrithm
            algStudents.add(stuMichelle);// Michelle选修了Algrithm

            courseDS.setStudents(dsStudents);
            courseAlg.setStudents(algStudents);

            sess.save(courseDS);
            sess.save(courseAlg);

            tx.commit();
        } catch (Exception e) {
            e.printStackTrace();
            tx.rollback();
        } finally {
            // sess.close();//与本地线程绑定后就不需要close了;
            HibernateUtils.closeSessionFactory();// 实际开发中不需要关闭
        }
    }

    /**
     * 因为hibernate的有双向维护外键的机制,所以会导致两次修改,在主表中设置属性inverse="true"(主表:一对多中的"一")
     * <set name="employees" cascade="save-update,delete" inverse="true">
     */
    private void testCascadeUpdate() {
        Session sess = null;
        Transaction tx = null;

        try {
            sess = HibernateUtils.getBoundSession();
            tx = sess.beginTransaction();

            // 级联修改,将6号员工bdemp_1设为ali的员工
            Company comAli = sess.get(Company.class, 3);
            Employee emp = sess.get(Employee.class, 6);

            comAli.getEmployees().add(emp);
            emp.setCompany(comAli);

            tx.commit();
        } catch (Exception e) {
            e.printStackTrace();
            tx.rollback();
        } finally {
            // sess.close();//与本地线程绑定后就不需要close了;
            HibernateUtils.closeSessionFactory();// 实际开发中不需要关闭
        }
    }

    /**
     * 如要级联删除,还需添加配置:<set name="contacts" cascade="save-update,delete">
     */
    private void testCascadeDelete() {
        Session sess = null;
        Transaction tx = null;

        try {
            sess = HibernateUtils.getBoundSession();
            tx = sess.beginTransaction();

            // 级联删除一个公司(customer)和两个员工(contact)
            sess.delete(sess.get(Company.class, 2));

            tx.commit();
        } catch (Exception e) {
            e.printStackTrace();
            tx.rollback();
        } finally {
            // sess.close();//与本地线程绑定后就不需要close了;
            HibernateUtils.closeSessionFactory();// 实际开发中不需要关闭
        }
    }

    /**
     * 级联保存的简化写法(在此之前需要配置映射文件cascade="save-update")
     */
    private void testCascadeSave_2() {
        Session sess = null;
        Transaction tx = null;

        try {
            sess = HibernateUtils.getBoundSession();
            tx = sess.beginTransaction();
            // 级联添加一个公司(customer)和两个员工(contact)
            Company compAli = new Company(null, "Alibaba", "Hangzhou", new HashSet<Employee>());
            Employee emp_1 = new Employee(null, "Aliemp_1", "female", null);
            Employee emp_2 = new Employee(null, "Aliemp_2", "male", null);

            // 把员工对象 放到公司对象的set集合里面
            compAli.getEmployees().add(emp_1);
            compAli.getEmployees().add(emp_2);

            sess.save(compAli);// 仅需要保存公司即可

            tx.commit();
        } catch (Exception e) {
            e.printStackTrace();
            tx.rollback();
        } finally {
            // sess.close();//与本地线程绑定后就不需要close了;
            HibernateUtils.closeSessionFactory();// 实际开发中不需要关闭
        }
    }

    /**
     * 级联操作的演示(复杂写法)
     */
    private void testCascadeSave_1() {
        Session sess = null;
        Transaction tx = null;

        try {
            sess = HibernateUtils.getBoundSession();
            tx = sess.beginTransaction();
            // 级联添加一个公司(customer)和两个员工(contact)
            Company comBd = new Company(null, "baidu", "Beijing", null);
            Employee emp_1 = new Employee(null, "bdemp_1", "female", null);
            Employee emp_2 = new Employee(null, "bdemp_2", "male", null);

            Set<Employee> bdemps = new HashSet<Employee>();
            bdemps.add(emp_1);
            bdemps.add(emp_2);

            // 把员工对象 放到公司对象的set集合里面
            comBd.setEmployees(bdemps);
            // 把公司对象放到员工里面
            emp_1.setCompany(comBd);
            emp_1.setCompany(comBd);

            sess.save(comBd);
            sess.save(emp_1);
            sess.save(emp_2);

            tx.commit();
        } catch (Exception e) {
            e.printStackTrace();
            tx.rollback();
        } finally {
            // sess.close();//与本地线程绑定后就不需要close了;
            HibernateUtils.closeSessionFactory();// 实际开发中不需要关闭
        }
    }

    private void testSQLQuery() {
        Session sess = null;
        Transaction tx = null;

        try {
            sess = HibernateUtils.getBoundSession();

            tx = sess.beginTransaction();

            SQLQuery sqlQuery = sess.createSQLQuery("SELECT * FROM t_user");

            // System.out.println("way 1 : ");
            // List<Object[]> userList = sqlQuery.list();
            // for (Object[] aList : userList) {
            // System.out.println(Arrays.toString(aList));
            // }

            // System.out.println("way 2 : ");
            sqlQuery.addEntity(User.class);
            List<User> userList_2 = sqlQuery.list();
            for (User user : userList_2) {
                System.out.println(user.getUsername() + " : " + user.getPassword());
            }

            tx.commit();
        } catch (Exception e) {
            e.printStackTrace();
            tx.rollback();
        } finally {
            // sess.close();//与本地线程绑定后就不需要close了;
            HibernateUtils.closeSessionFactory();
        }
    }

    private void testCriteria() {
        Session sess = null;
        Transaction tx = null;

        try {
            sess = HibernateUtils.getBoundSession();

            tx = sess.beginTransaction();

            Criteria criteria = sess.createCriteria(User.class);
            List<User> userList = criteria.list();

            for (User user : userList) {
                System.out.println(user.getUsername() + " : " + user.getPassword());
            }

            tx.commit();
        } catch (Exception e) {
            e.printStackTrace();
            tx.rollback();
        } finally {
            // sess.close();//与本地线程绑定后就不需要close了;
            HibernateUtils.closeSessionFactory();
        }
    }

    private void testQuery() {
        Session sess = null;
        Transaction tx = null;

        try {
            sess = HibernateUtils.getBoundSession();

            tx = sess.beginTransaction();

            Query query = sess.createQuery("from User");
            List<User> userList = query.list();

            for (User user : userList) {
                System.out.println(user.getUsername() + " : " + user.getPassword());
            }

            tx.commit();
        } catch (Exception e) {
            e.printStackTrace();
            tx.rollback();
        } finally {
            // sess.close();//与本地线程绑定后就不需要close了;
            HibernateUtils.closeSessionFactory();
        }
    }

    private void testBoundSession() {

        Session sess = null;
        Transaction tx = null;

        try {
            sess = HibernateUtils.getBoundSession();

            tx = sess.beginTransaction();

            User user = new User();
            user.setUsername("李san");

            sess.saveOrUpdate(user);

            tx.commit();
        } catch (Exception e) {
            e.printStackTrace();
            tx.rollback();
        } finally {
            // sess.close();//与本地线程绑定后就不需要close了;
        }
    }

    private void testSaveOrUpdate() {

        Session sess = HibernateUtils.getSessionFactory().openSession();

        Transaction tx = sess.beginTransaction();

        // User user = sess.get(User.class, 3);
        // User user = new User();
        // user.setUid(3);
        // user.setUsername("张");
        // sess.save(user);

        User user = new User();
        user.setUid(3);
        user.setUsername("李");
        sess.saveOrUpdate(user);

        tx.commit();

        sess.close();
    }

    private void testDelete() {
        Session sess = HibernateUtils.getSessionFactory().openSession();

        Transaction tx = sess.beginTransaction();

        // way 1:
        // User user = sess.get(User.class, 1);
        // sess.delete(user);

        // way 2:
        User user_2 = new User();
        user_2.setUid(2);
        sess.delete(user_2);

        tx.commit();

        sess.close();
    }

    private void testUpdate() {

        Session sess = HibernateUtils.getSessionFactory().openSession();

        Transaction tx = sess.beginTransaction();

        User user = sess.get(User.class, 1);
        user.setUsername("sunguoqing");
        sess.update(user);

        tx.commit();

        sess.close();
    }

    private void testGet() {
        Session sess = HibernateUtils.getSessionFactory().openSession();

        Transaction tx = sess.beginTransaction();

        User user = sess.get(User.class, 1);

        System.out.println(user.getUsername() + " : " + user.getPassword());

        tx.commit();

        sess.close();
    }

    private void testAdd() {

        Session sess = HibernateUtils.getSessionFactory().openSession();

        Transaction tx = sess.beginTransaction();

        User user = new User();
        user.setUsername("孙国庆4");
        user.setPassword("254");

        sess.save(user);

        tx.commit();

        sess.close();
        // HibernateUtils.closeSessionFactory();
    }

}

part_16:视图
这里写图片描述

part_17:下载源码(http://download.csdn.net/detail/love_legain/9744626)

LLEGAIN
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
测试集(2)-words
马如林的IT博客
11-26 5万+
 aa.ma.mabandonabandonabattoirabilityabilityableableabnormalabnormalaboardaboardaboutaboutaboveaboveabracadabraabroadabroadabsenceabsenceabsentabsent
Hibernate usage
tomboxfan
03-24 119
hibernate logging &nbsp; ## print all generated SQL to the consolehibernate.show_sql true&nbsp;&nbsp; ## format SQL in log and consolehibernate.format_sql&nbsp; true&nbsp;&nbsp; ## add comments to ...
EhCache,Hibernate二级缓存,cache usage
weixin_33804990的博客
09-20 166
1.EhCache是什么 EhCache是Hibernate的二级缓存技术之一，可以把查询出来的数据存储在内存或者磁盘，节省下次同样查询语句再次查询数据库，大幅减轻数据库压力； 2.EhCache的使用注意点 当用Hibernate的方式修改表数据(save,update,delete等等)，这时EhCache会自动把缓存中关于此表的所有缓存全部删除掉(这样能达到同步)...
昇腾Ascend处理器相关介绍
最新发布
IT菜鸟
10-08 8405
昇腾AI处理器本质上是一个片上系统（System on Chip，SoC），该芯片大致可以划为：芯片系统控制CPU（Control CPU），AI计算引擎（包括AI Core和AI CPU），多层级的片上系统缓存（Cache）或缓冲区（Buffer），数字视觉预处理模块（Digital Vision Pre-Processing，DVPP）等。目前主流SoC芯片的主存一般由DDR（Double Data Rate）或HBM（High Bandwidth Memory）构成，用来存放大量的数据。
【2022年第一期 CANN训练营进阶班模型课】第一次大作业和附加内容
qq_40679625的博客
04-24 392
前情提要 1. PyCharm常用操作和配置ModelArts插件使用，官方文档和介绍较为详细，这里不在叙述 2. 需要说明的是，我是用的插件版本是3.3.5，比教程中的应该是新一些，所以有些配置不同，主要是两点：（1）Image Path按照教程设置无效，导致无法启动训练作业，直接不设置就行了；（2）Data Path，即数据集存放路径，必须是本人账号的桶路径才行（也可能是因为教程中的桶区域不是北京四），所以无法按照教程设置，我下载数据集后，上传到自己的桶中，并指定路径即可。 操作 1. 直接
HBM (High Bandwidth Memory)
limanjihe的专栏
05-06 8294
https://www.amd.com/en/technologies/hbm https://www.amd.com/system/files/documents/high-bandwidth-memory-hbm.pdf HBM is a new type of CPU/GPU memory (“RAM”) that vertically stacks memory chips, like...
HibernateDemo(hibernate基本用法演示)
01-23
**Hibernate 框架基础与应用** ...配合博客教程 `Hibernate-Usage(basis)`，你可以逐步了解并实践这些概念，从而深入理解 Hibernate 的核心功能和工作原理。通过实际操作，将有助于你更好地掌握这个强大的持久化框架。
继承 HibernateDaoSupport 的getSession 问题
kingwhere的专栏
09-24 1785
这段时间遇到一个问题，接收的项目Dao继承的是 HibernateDaoSupport 且没有加上事务 在进行后期测试的时间发现web服务器内存爆掉了，后来检测了一下session的开启数，发现有很多session没有关掉，因为这个问题就到网上查了资料，网上大部分的解决如下 1.重写 HibernateDaoSupport用ThreadLocal保存Session列表并编写一个配套的过滤器
A002-185-2531
GONGZIXUY的博客
01-05 1382
目录 第一页作业 2 1.1验收承认(acceptance) 2 1.2要求需要(requirement) 5 1.3最初形态(Prototype) 6 1.4Model(模型) 7 1.5异义词(Homonym) 8 1.6检查(Inspection) 8 1.7敏捷式项目管理(Agile project management) 9 1.8特征(Feature) 10 1.9实体(Entity) 12 1.10错误(Error) 14 第二页作业 15 2.1实现视图(implementation vie
spring boot应用p6spy监控sql
atlim的专栏
07-14 9889
Spring boot中使用p6spy监控hibernate sql语句值开发环境 开发工具：IDEA 开发环境：spring mvc、spring boot、spring data 数据库:mysql 具体步骤如下： pom.xml中添加p6spy包依赖： <dependency> <groupId>p6spy</groupId> <
HBM内存介绍
qq_43649693的博客
09-20 1万+
原帖地址：http://www.anandtech.com/show/9969/jedec-publishes-hbm2-specification 高带宽存储器（HBM）技术解决了与现代DRAM相关的两个关键问题：它显着增加了计算设备（例如GPU）可用的带宽并降低了功耗。第一代HBM在容量和时钟速率方面有许多限制。但是，第二代HBM有望消除它们。 制定DRAM标准的主要半导体工程贸易组织JEDEC最近发布了第二代HBM（HBM2）的最终规范，这意味着该组织的成员已经批准了该标准。新的存储技术建立在原始JE
Java三大框架之——Hibernate中的三种数据持久状态和缓存机制
weixin_33691700的博客
11-25 204
Hibernate中的三种状态 　 瞬时状态：刚创建的对象还没有被Session持久化、缓存中不存在这个对象的数据并且数据库中没有这个对象对应的数据为瞬时状态这个时候是没有OID。　　　 　　持久状态：对象经过Session持久化操作，缓存中存在这个对象的数据为持久状态并且数据库中存在这个对象对应的数据为持久状态这个时候有OID。 　　游离状态：当Session关闭，缓存中不存在这个对象...
Hibernate的cache管理
weixin_34232617的博客
01-11 183
Cache就是缓存，它往往是提高系统性能的最重要手段，对数据起到一个蓄水池和缓冲的作用。Cache对于大量依赖数据读取操作的系统而言尤其重要。在大并发量的情况下，如果每次程序都需要向数据库直接做查询操作，它们所带来的性能开销是显而易见的，频繁的网络舆，数据库磁盘的读写操作都会大大降低系统的性能。此时如果能让数据库在本地内存中保留一个镜像，下次访问的时候只需要从内存中直接获取，那么显然可以带来不小的...
Hibernate缓存(一)
JAVA
10-26 183
缓存可以简单的看成一个 Map ，通过 key 在缓存里面找 value 。   一、缓存简介   Cache In Hibernate HIBERNATE 中的 CACHE 有两级 . 一级是在 Session 范围内的 CACHE . 即每个 Session 有...
Hibernate之缓存详解
热门推荐
浅浅请留步
08-03 3万+
一，缓存的概念 二，缓存的范围 三，Hibernate中的第一级缓存 1，get查询测试： 1>在同一个session中发出两次get查询 public void Query(){ Session sess = HibernateSessionFactory.getSession(); Transaction tx = sess.beginTransaction(); St
Hibernate注解版关联关系映射全解析+案例
行走的IT
03-16 6124
HIbernate注解说明 [java] view plain copy   1、@Entity(name="EntityName")   必须,name为可选,对应数据库中一的个表，此处的EntryName要注意，在代码中使用hql进行查询时，需要from Xxx，那么Xxx就是对应的此处的EntryName，所以要注意EntryName的命名，否
Mybatis官方参考文档---mybatis-3.2.7.pdf
We get old too soon and wise too late
04-16 1461
Ref : by Mike Sun @ 20170416 Sun
Spring的各个模块与导包原则
We get old too soon and wise too late
04-17 1307
Ref : Ref : Ref : Ref : The Spring Framework consists of features organized into about 20 modules. These modules are grouped into Core Container, Data Access/Integration, Web, AOP (Aspect Orient
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值