hibernate 框架的简单使用

<?xml version="1.0" encoding="UTF-8"?>

<!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:///test</property>

        <property name="hibernate.connection.username">LF</property>

        <property name="hibernate.connection.password">LF</property>

        <!-- 配置hibernate信息  可选的-->

        <!-- 输出底层sql语句 -->

        <property name="hibernate.show_sql">true</property>

        <!-- 输出底层sql语句格式 -->

        <property name="hibernate.format_sql">true</property>

        <!-- hibernate帮创建表，需要配置之后

            update：如果已经有表，更新，如果没有，创建

        -->

        <property name="hibernate.hbm2ddl.auto">update</property>

        <!-- 配置数据库方言

            在mysql里面实现分页 关键字limit，只能使用mysql里面

            在Oracle数据库，实现分页rownum

            让hibernate框架识别不同数据库的自己特有的语句

        -->

        <property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property>

        <!-- 在hibernate核心文件配置 -->

        <property name="hibernate.current_session_context_class">thread</property>

        <!-- 把映射文件放在核心配置文件中 必须的 -->

        <mapping resource="cn/zr/hibernate/entity/User.hbm.xml"/>

    </session-factory>

</hibernate-configuration>

<?xml version="1.0" encoding="UTF-8"?>

<!DOCTYPE hibernate-mapping PUBLIC

    "-//Hibernate/Hibernate Mapping DTD 3.0//EN"

    "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">

<hibernate-mapping>

    <!-- 配置类和表对应

        class标签

        name属性:实体类全路径

        table属性：数据库表名称

     -->

    <class name="cn.zr.hibernate.entity.User" table="t_user">

        <!-- 配置实体类id和表id对应

            name属性:实体类里面id属性名称

            column属性:生成的表字段名称

        -->

        <id name="uid" column="uid">

            <!-- 设置数据库表id增长策略

                native：生成id值就是主键自动增长

             -->

            <generator class="native"></generator>

        </id>

        <!-- 配置其他属性与表字段对应

             name属性:实体类属性名称

             column属性：生成表字段名称

        -->

        <property name="username" column="username"></property>

        <property name="password" column="password"></property>

        <property name="address" column="address"></property>

    </class>

</hibernate-mapping>

package cn.zr.hibernate.entity;

/**

 *

 * @author lf

 *

 * 2017年2月12日

 */

public class User {

    /*hibernate要求实体类有一个属性唯一的*/

    private int uid;

    private String username;

    private String password;

    private String address;

    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;

    }

    public String getAddress() {

        return address;

    }

    public void setAddress(String address) {

        this.address = address;

    }

    public User() {

        super();

    }

    public User(int uid, String username, String password, String address) {

        super();

        this.uid = uid;

        this.username = username;

        this.password = password;

        this.address = address;

    }

    @Override

    public String toString() {

        return "User [uid=" + uid + ", username=" + username + ", password=" + password + ", address=" + address + "]";

    }

}

package cn.zr.hibernate.utils;

import org.hibernate.Session;

import org.hibernate.SessionFactory;

import org.hibernate.cfg.Configuration;

import org.hibernate.service.ServiceRegistry;

import org.hibernate.service.ServiceRegistryBuilder;

public class HibernateUtils {

    private static Configuration configuration = null;

    private static SessionFactory sessionFactory = null;

    // 静态代码块实现（只初始化一次）

    static{

        /*加载hibernate核心配置文件*/

        // 创建Configuration对象

        configuration = new Configuration();

        // 会自动在src文件目录下找hibernate.cfg.mxl文件

        configuration.configure();

        ServiceRegistry serviceRegistry = new ServiceRegistryBuilder().applySettings(configuration.getProperties()).buildServiceRegistry();

        // 创建SessionFactory对象

        // 在过程中，根据映射关系，在配置数据库里面把表创建

        sessionFactory = configuration.buildSessionFactory(serviceRegistry);

    }

    //提供返回与本地线程帮的session的方法

    public static Session getSessionObject(){

        return sessionFactory.getCurrentSession();

    }

    // 提供方法返回sessionFactory

    public static SessionFactory getSessionFactory() {

        return sessionFactory;

    }

}

package cn.zr.hibernate.test;

import java.util.Arrays;

import java.util.List;

import org.hibernate.Criteria;

import org.hibernate.Query;

import org.hibernate.SQLQuery;

import org.hibernate.Session;

import org.hibernate.SessionFactory;

import org.hibernate.Transaction;

import cn.zr.hibernate.entity.User;

import cn.zr.hibernate.utils.HibernateUtils;

public class HibernateTest {

    public static void main(String[] args) {

        HibernateTest hibernateTest = new HibernateTest();

//        hibernateTest.addUser();

//        User user = hibernateTest.queryUserById(1);

//        System.out.println(user);

//        hibernateTest.updateUserInfomation(1, "dew");

//        hibernateTest.deleteUser(1);

//        hibernateTest.queryByQuery();

//        hibernateTest.queryByCriteria();

        hibernateTest.queryBySQLQuery();

    }

    /**

     * 添加用户

     */

    public void addUser() {

        Session session = null;

        Transaction transaction = null;

        try {

            // 获取session对象

            session = HibernateUtils.getSessionObject();

            // 开启事务

            transaction = session.beginTransaction();

            // 添加功能

            User user = new User();

            user.setUsername("lf");

            user.setPassword("123456");

            user.setAddress("China");

            session.save(user);

            // 提交事务

            transaction.commit();

        } catch (Exception e) {

            e.printStackTrace();

            //回滚事务

            transaction.rollback();

        }finally {

            // 关闭资源（与线程绑定后不需要手动关闭，当线程结束后，会自动关闭）

//            session.close();

        }

    }

    /**

     * 通过id查询用户

     * @param id

     * @return 返回用户

     */

    public User queryUserById(int id) {

        Session session = null;

        Transaction transaction = null;

        User user = null;

        try {

            // 获取session对象

            session = HibernateUtils.getSessionObject();

            // 开启事务

            transaction = session.beginTransaction();

            /*

             *  第一参数：实体类的class

             *  第二个参数：id值

             * */

            user = (User) session.get(User.class, id);

            // 提交事务

            transaction.commit();

        } catch (Exception e) {

            e.printStackTrace();

            //事务回滚

            transaction.rollback();

        }finally {

            // 关闭资源（与线程绑定后不需要手动关闭，当线程结束后，会自动关闭）

//            session.close();

        }

        return user;

    }

    /**

     * 通过id 来修改用户名

     * @param id

     * @param username

     */

    public void updateUserInfomation(int id,String username) {

        Session session = null;

        Transaction transaction = null;

        try {

            // 获取session对象

            session = HibernateUtils.getSessionObject();

            // 开启事务

            transaction = session.beginTransaction();

            /*

             *  第一参数：实体类的class

             *  第二个参数：id值

             * */

            User user = (User) session.get(User.class, id);

            //设置修改值

            user.setUsername(username);

            // 更新

            session.update(user);

            // 提交事务

            transaction.commit();

        } catch (Exception e) {

            e.printStackTrace();

            // 事务回滚

            transaction.rollback();

        }finally {

            // 关闭资源（与线程绑定后不需要手动关闭，当线程结束后，会自动关闭）

//            session.close();

        }

    }

    /**

     * 通过id删除用户

     */

    public void deleteUser(int id) {

        Session session = null;

        Transaction transaction = null;

        try {

            // 获取session对象

            session = HibernateUtils.getSessionObject();

            // 开启事务

            transaction = session.beginTransaction();

            /*

             * 第一种：先通过id查出用户，后删除

             * */

            User user = (User) session.get(User.class, id);

            session.delete(user);

            /*

             * 第二种

             * */

//            User user = new User();

//            user.setUid(id);

//            session.delete(user);

            // 提交事务

            transaction.commit();

        } catch (Exception e) {

            e.printStackTrace();

            // 事务回滚

            transaction.rollback();

        }finally {

            // 关闭资源（与线程绑定后不需要手动关闭，当线程结束后，会自动关闭）

//            session.close();

        }

    }

    /**

     * 通过Query对象去查询

     */

    public void queryByQuery() {

        Session session = null;

        Transaction transaction = null;

        try {

            // 获取session对象

            session = HibernateUtils.getSessionObject();

            // 开启事务

            transaction = session.beginTransaction();

            //创建Query对象

            // 方法里面写hql语句

            Query query = session.createQuery("from User");

            // 调用query对象里面的方法得到结果

            List<User> list = query.list();

            for (User user : list) {

                System.out.println(user);

            }

            // 提交事务

            transaction.commit();

        } catch (Exception e) {

            e.printStackTrace();

            //回滚事务

            transaction.rollback();

        }

    }

    /**

     * 通过Criteria对象去查询

     */

    public void queryByCriteria() {

        Session session = null;

        Transaction transaction = null;

        try {

            // 获取session对象

            session = HibernateUtils.getSessionObject();

            // 开启事务

            transaction = session.beginTransaction();

            //创建Criteria对象

            Criteria criteria = session.createCriteria(User.class);

            // 调用criteria对象里面的方法得到结果

            List<User> list = criteria.list();

            for (User user : list) {

                System.out.println(user);

            }

            // 提交事务

            transaction.commit();

        } catch (Exception e) {

            e.printStackTrace();

            //回滚事务

            transaction.rollback();

        }

    }

    /**

     * 通过SQLQuery对象去查询

     */

    public void queryBySQLQuery() {

        Session session = null;

        Transaction transaction = null;

        try {

            // 获取session对象

            session = HibernateUtils.getSessionObject();

            // 开启事务

            transaction = session.beginTransaction();

            //创建SQLQuery对象

            SQLQuery sqlQuery = session.createSQLQuery("select * from t_user");

            // 设置返回list中的对象

            sqlQuery.addEntity(User.class);

            List<User> list = sqlQuery.list();

            for (User user : list) {

                System.out.println(user);

            }

            /*

            // 调用SQLQuery对象里面的方法得到结果(返回list集合，默认里面每部分都是数组结构)

            List<Object[]> list = sqlQuery.list();

            for (Object[] objects : list) {

                System.out.println(Arrays.toString(objects));

            }

            */

            // 提交事务

            transaction.commit();

        } catch (Exception e) {

            e.printStackTrace();

            //回滚事务

            transaction.rollback();

        }

    }

}

巴特西

hibernate 框架的简单使用

最新文章

热门文章