Hibernate框架的学习--第四天

最新推荐文章于 2024-07-12 15:51:39 发布
最新推荐文章于 2024-07-12 15:51:39 发布
阅读量89 收藏
点赞数
文章标签： java 数据库
原文链接：http://www.cnblogs.com/guodong-wang/p/7511304.html
版权

一、 Hibernate查询高级

    1. 查询总结

        1.oid查询-get

       2.对象属性导航查询

       3.HQL

       4.Criteria

       5.原生SQL

   2. 查询-HQL语法

        1）基础语法      

   /**
     * 基本语法
     */
    @Test
    public void fun1() {
        //1. 获得session
        Session session = HibernateUtils.getSession();
        //2. 开启事务并获得操作事务的对象
        Transaction tx = session.beginTransaction();
        //3. 执行操作
        
        //1>定义hql语句
        String hql1 = "from com.java.domain.Customer"; //完整写法  
        String hql2 = "from Customer"; //简单写法
        //2>创建查询的对象
        Query query = session.createQuery(hql2);
        //3>执行查询操作
        List<Customer> list = query.list();
        System.out.println(list);
        
        //4. 提交事务并释放资源
        tx.commit();
        session.close();
        
    }

　　2）排序     

　　/**
     * 排序查询
     * 
     */
    @Test
    public void fun2() {
        //1. 获得session
        Session session = HibernateUtils.getSession();
        //2. 开启事务并获得操作事务的对象
        Transaction tx = session.beginTransaction();
        //3. 执行操作
        
        //1>定义hql语句
        String hql1 = "from Customer order by cust_id desc"; //降序查询
        String hql2 = "from Customer order by cust_id asc"; //升序查询
        //2>创建查询的对象
        Query query = session.createQuery(hql2);
        //3>执行查询操作
        List<Customer> list = query.list();
        System.out.println(list);
        
        //4. 提交事务并释放资源
        tx.commit();
        session.close();
        
    }

　　3）条件查询

          ？占位符和命名占位符 

　　/**
     * 条件查询
     * ?占位符
     * 命名占位符
     */
    @Test
    public void fun3() {
        //1. 获得session
        Session session = HibernateUtils.getSession();
        //2. 开启事务并获得操作事务的对象
        Transaction tx = session.beginTransaction();
        //3. 执行操作
        
        //1>定义hql语句
        String hql1 = "from Customer where cust_id=?"; //简单写法
        String hql2 = "from Customer where cust_id=:cust_id";
        //2>创建查询的对象
        Query query = session.createQuery(hql2);
        
        //设置查询的参数
        //query.setParameter(0, 1l);
        query.setParameter("cust_id", 1l);
        //3>执行查询操作
        List<Customer> list = query.list();
        System.out.println(list);
        
        //4. 提交事务并释放资源
        tx.commit();
        session.close();
        
    }

　　4）分页查询        

　　    limit ?,?
　　   query.setFirstResult(2);
　　   query.setMaxResults(2); 

    /**
     * 分页查询
     * limit ?,?
     *    query.setFirstResult(2);
     *    query.setMaxResults(2);
     */
    @Test
    public void fun4() {
        //1. 获得session
        Session session = HibernateUtils.getSession();
        //2. 开启事务并获得操作事务的对象
        Transaction tx = session.beginTransaction();
        //3. 执行操作
        
        //1>定义hql语句
        String hql = "from Customer"; //简单写法
        //2>创建查询的对象
        Query query = session.createQuery(hql);
        
        //limit ?,?
        query.setFirstResult(2);
        query.setMaxResults(2);
        
        //3>执行查询操作
        List<Customer> list = query.list();
        System.out.println(list);
        
        //4. 提交事务并释放资源
        tx.commit();
        session.close();
        
    }

　　5）统计检索（聚合函数）

　　/**
     * 统计检索(聚合函数)
     *    
     */
    @Test
    public void fun5() {
        //1. 获得session
        Session session = HibernateUtils.getSession();
        //2. 开启事务并获得操作事务的对象
        Transaction tx = session.beginTransaction();
        //3. 执行操作
        
        //1>定义hql语句
        String hql1 = "select count(*) from Customer"; //简单写法
        String hql2 = "select sum(cust_id) from Customer"; //简单写法
        String hql3 = "select avg(cust_id) from Customer"; //简单写法
        String hql4 = "select min(cust_id) from Customer"; //简单写法
        String hql5 = "select max(cust_id) from Customer"; //简单写法
        //2>创建查询的对象
        Query query = session.createQuery(hql5);
        
        //3>执行查询操作
        Number result = (Number) query.uniqueResult();
        System.out.println(result);
        
        //4. 提交事务并释放资源
        tx.commit();
        session.close();
        
    }

　　6）投影查询

　　/**
     * 投影查询
     *    
     */
    @Test
    public void fun6() {
        //1. 获得session
        Session session = HibernateUtils.getSession();
        //2. 开启事务并获得操作事务的对象
        Transaction tx = session.beginTransaction();
        //3. 执行操作
        
        //1>定义hql语句
        String hql1 = "select cust_id from Customer"; //简单写法
        String hql2 = "select cust_id,cust_name from Customer"; //简单写法
        String hql3 = "select new Customer(cust_id, cust_name) from Customer"; //简单写法
        //2>创建查询的对象
        Query query = session.createQuery(hql3);
        
        //3>执行查询操作
        List list = query.list();
        System.out.println(list);
        
        //4. 提交事务并释放资源
        tx.commit();
        session.close();
        
    }

　　7）多表查询

        

     1) 原生SQL

        交叉连接-笛卡尔积(避免)
       select * from A,B
       内连接
            |-隐式内连接
　　　　select * from A,B where B.aid=A.aid
  　　   |-显式内连接
　　        select * from A inner join B on B.aid=A.aid
　　外连接
　　　 |-左外连接
　　　　select * from A left [outer] B on B.aid=A.aid
　　     |-右外连接
　　　　select * from A right [outer] B on B.aid=A.aid

    2）HQL的多表查询

　　 内连接(迫切)
　　 外连接
　　    |-左外(迫切)
　　    |-右外(迫切)

    3）HQL多表查询的案例

public class Demo02 {
    /**
     * 内连接
     * 将连接两端的对象分别返回放入数组
     */
    @Test
    public void fun1() {
        //1. 获得session
        Session session = HibernateUtils.getSession();
        //2. 开启事务并获得操作事务的对象
        Transaction tx = session.beginTransaction();
        //3. 执行操作
        
        //1>定义hql语句
        String hql = "from Customer c inner join c.linkMens"; //完整写法  
        //2>创建查询的对象
        Query query = session.createQuery(hql);
        //3>执行查询操作
        List<String[]> list = query.list();
        for(Object[] obj : list) {
            System.out.println(Arrays.toString(obj));
        }
        
        //4. 提交事务并释放资源
        tx.commit();
        session.close();
        
    }
    /**
     * 内连接迫切
     * 将两端的对象封装成一个对象返回
     * from Customer c inner join c.linkMens
     */
    @Test
    public void fun2() {
        //1. 获得session
        Session session = HibernateUtils.getSession();
        //2. 开启事务并获得操作事务的对象
        Transaction tx = session.beginTransaction();
        //3. 执行操作
        
        //1>定义hql语句
        String hql = "from Customer c inner join fetch c.linkMens"; //完整写法  
        //2>创建查询的对象
        Query query = session.createQuery(hql);
        //3>执行查询操作
        List<Customer> list = query.list();
        for(Customer c : list) {
            System.out.println(c);
        }
        
        //4. 提交事务并释放资源
        tx.commit();
        session.close();
        
    }
    /**
     * 左外连接
     * 将连接两端的对象分别返回并放到数组中
     * from Customer c left join c.linkMens
     */
    @Test
    public void fun3() {
        //1. 获得session
        Session session = HibernateUtils.getSession();
        //2. 开启事务并获得操作事务的对象
        Transaction tx = session.beginTransaction();
        //3. 执行操作
        
        //1>定义hql语句
        String hql = "from Customer c left join c.linkMens"; //完整写法  
        //2>创建查询的对象
        Query query = session.createQuery(hql);
        //3>执行查询操作
        List<Object[]> list = query.list();
        for(Object[] obj : list) {
            System.out.println(Arrays.toString(obj));
        }
        
        //4. 提交事务并释放资源
        tx.commit();
        session.close();
        
    }
    
    /**
     * 右外连接
     * 将连接两端的对象分别返回并放到数组中
     * from Customer c right join c.linkMens
     */
    @Test
    public void fun4() {
        //1. 获得session
        Session session = HibernateUtils.getSession();
        //2. 开启事务并获得操作事务的对象
        Transaction tx = session.beginTransaction();
        //3. 执行操作
        
        //1>定义hql语句
        String hql = "from Customer c right join c.linkMens"; //完整写法  
        //2>创建查询的对象
        Query query = session.createQuery(hql);
        //3>执行查询操作
        List<Object[]> list = query.list();
        for(Object[] obj : list) {
            System.out.println(Arrays.toString(obj));
        }
        
        //4. 提交事务并释放资源
        tx.commit();
        session.close();
        
    }  
}

  3. 查询-Criteria语法

   1)基本知识

           QBC（Query By Criteria）是hibernate提高的另一种检索对象的方式，它主要由Criteria接口Criterion接口和Expression类组成。Criteria接口是Hibernate API中的一个查询接口，它需由session进行创建。Criterion是Criteria的查询条件，在Criteria中提供了add(Criterion criterion)方法来添加查询条件。使用QBC检索对象的示例代码如下：     

　　　　//1>创建ceriteria对象
        Criteria criteria = session.createCriteria(Customer.class);
        
        //2>添加查询条件
        //criteria.add(Restrictions.idEq(1l));
        criteria.add(Restrictions.eq("cust_id", 1l));
        //3>执行查询
        List<Customer> list = criteria.list();

　　QBC检索是使用Restrictions对象编写查询条件的，在Restrictions类中提供了大量的静态方法来创建查询条件，其常用的方法如表所示：                  

          

　　2）基本查询

    /**
     * 基本语法
     */
    @Test
    public void fun1() {
        //1. 获得session
        Session session = HibernateUtils.getSession();
        //2. 开启事务并获得操作事务的对象
        Transaction tx = session.beginTransaction();
        //3. 执行操作
        
        //1>创建ceriteria对象
        Criteria criteria = session.createCriteria(LinkMan.class);
        
        //2>执行查询
        List<LinkMan> list = criteria.list();
        System.out.println(list);
        
        //4. 提交事务并释放资源
        tx.commit();
        session.close();
        
    }

　　2）条件查询

　　/**
     * 条件查询
     */
    @Test
    public void fun2() {
        //1. 获得session
        Session session = HibernateUtils.getSession();
        //2. 开启事务并获得操作事务的对象
        Transaction tx = session.beginTransaction();
        //3. 执行操作
        
        //1>创建ceriteria对象
        Criteria criteria = session.createCriteria(Customer.class);
        
        //2>添加查询条件
        //criteria.add(Restrictions.idEq(1l));
        criteria.add(Restrictions.eq("cust_id", 1l));
        //3>执行查询
        List<Customer> list = criteria.list();
        System.out.println(list);
        
        //4. 提交事务并释放资源
        tx.commit();
        session.close();
        
    }

　　3）分页查询

/**
     * 分页查询
     * limit ?,?
     * criteria.setFirstResult(0);
     * criteria.setMaxResults(2);
     */
    @Test
    public void fun3() {
        //1. 获得session
        Session session = HibernateUtils.getSession();
        //2. 开启事务并获得操作事务的对象
        Transaction tx = session.beginTransaction();
        //3. 执行操作
        
        //1>创建ceriteria对象
        Criteria criteria = session.createCriteria(Customer.class);
        
        //2>设置分页查询的参数 limit ?,?
        criteria.setFirstResult(0);
        criteria.setMaxResults(2);
        
        //3>执行查询
        List<Customer> list = criteria.list();
        System.out.println(list);
        
        //4. 提交事务并释放资源
        tx.commit();
        session.close();
        
    }

　　4）排序查询

/**
     * 排序查询
     *  criteria.addOrder(Order.asc("cust_id")); //升序查询
     *    criteria.addOrder(Order.desc("cust_id")); //降序查询
     */
    @Test
    public void fun4() {
        //1. 获得session
        Session session = HibernateUtils.getSession();
        //2. 开启事务并获得操作事务的对象
        Transaction tx = session.beginTransaction();
        //3. 执行操作
        
        //1>创建ceriteria对象
        Criteria criteria = session.createCriteria(Customer.class);
        
        //2>添加排序条件
        //criteria.addOrder(Order.asc("cust_id")); //升序查询
        criteria.addOrder(Order.desc("cust_id")); //降序查询
        
        //3>执行查询
        List<Customer> list = criteria.list();
        System.out.println(list);
        
        //4. 提交事务并释放资源
        tx.commit();
        session.close();
    }

　　5）统计查询

/**
     * 统计查询
     * 总记录数 
     * criteria.setProjection(Projections.rowCount());
     */
    @Test
    public void fun5() {
        //1. 获得session
        Session session = HibernateUtils.getSession();
        //2. 开启事务并获得操作事务的对象
        Transaction tx = session.beginTransaction();
        //3. 执行操作
        
        //1>创建ceriteria对象
        Criteria criteria = session.createCriteria(Customer.class);
        
        //2>设置查询目标  总记录数
        criteria.setProjection(Projections.rowCount());
        
        //3>执行查询
        List<Customer> list = criteria.list();
        System.out.println(list);
        
        //4. 提交事务并释放资源
        tx.commit();
        session.close();
    }

  4. 查询优化

　1）类级别查询

        get方法:没有任何策略.调用即立即查询数据库加载数据.

       load方法: 应用类级别的加载策略       

　　懒加载 延迟加载
　　 load()方法(默认)：是在执行时，不会发送任何sql语句，通过动态代理返回一个对象，
　　在对象使用的时候，才执行查询

 　　延迟加载：仅仅获得没有使用，不会查询。在使用时，才进行查询
 　　是否对类延迟加载可以通过在class元素上配置lazy属性
　　 lazy(默认):true 加载时不查询，使用时才查询
 　　lazy:false load方法与get方法没有任何区别 加载时立即查询

　　为了提高效率建议使用懒加载

public class Demo {
    /**
     * get()方法：立即加载。执行方法时立即发送sql语句查询结果
     */
    @Test
    public void fun1() {
        //1. 获得session
        Session session = HibernateUtils.getSession();
        //2. 开启事务并获得操作事务的对象
        Transaction tx = session.beginTransaction();
        //3. 执行操作
        
        Customer c = session.get(Customer.class, 2l);
        System.out.println(c);
        
        
        //4. 提交事务并释放资源
        tx.commit();
        session.close();
        
    }
    
    /**
     * load()方法(默认)：是在执行时，不会发送任何sql语句，通过动态代理返回一个对象，
     *                     在对象使用的时候，才执行查询
     * 延迟加载：仅仅获得没有使用，不会查询。在使用时，才进行查询
     * 是否对类延迟加载可以通过在class元素上配置lazy属性
     *  lazy(默认):true   加载时不查询，使用时才查询
     *  lazy:false  加载时立即查询
     */
    @Test
    public void fun2() {
        //1. 获得session
        Session session = HibernateUtils.getSession();
        //2. 开启事务并获得操作事务的对象
        Transaction tx = session.beginTransaction();
        //3. 执行操作
        
        Customer c = session.load(Customer.class, 2l);
        System.out.println(c);
        
        
        //4. 提交事务并释放资源
        tx.commit();
        session.close();
    }
    
    
}

　　2）关联级别查询

          1. 集合策略

　　     lazy属性：决定是否延迟加载
　　　     true(默认值):延迟加载，懒加载
　　        false:立即加载
　　　     extra：及其懒惰
　　     fetch属性：决定加载策略，使用什么类型的sql语句加载集合数据
                select(默认值):单表查询加载
　　         join：使用多表查询加载集合
　　         subselect:使用子查询加载查询集合           

/**
 * 
 *  关联级别  延迟加载
 *  集合级别的关联
 * @author vanguard
 *
 */
public class Demo {
    /**
     * 集合级别的关联
     * fetch:select  单表查询
     * lazy:true 延迟加载  使用时才加载集合数据
     */
    @Test
    public void fun1() {
        //1. 获得session
        Session session = HibernateUtils.getSession();
        //2. 开启事务并获得操作事务的对象
        Transaction tx = session.beginTransaction();
        //3. 执行操作
        
        Customer c = session.get(Customer.class, 2l);
        
        Set<LinkMan> linkMens = c.getLinkMens(); //关联级别
        
        System.out.println(linkMens);
        
        
        //4. 提交事务并释放资源
        tx.commit();
        session.close();
        
    }
    /**
     * 集合级别的关联
     * fetch:select  单表查询
     * lazy:false 立即加载数据
     */
    @Test
    public void fun2() {
        //1. 获得session
        Session session = HibernateUtils.getSession();
        //2. 开启事务并获得操作事务的对象
        Transaction tx = session.beginTransaction();
        //3. 执行操作
        
        Customer c = session.get(Customer.class, 2l);
        
        Set<LinkMan> linkMens = c.getLinkMens(); //关联级别
        
        System.out.println(linkMens);
        
        
        //4. 提交事务并释放资源
        tx.commit();
        session.close();
        
    }
    /**
     * 集合级别的关联
     * fetch:select  单表查询
     * lazy:extra 极其懒惰
     * 与懒加载效果基本一致. 如果只获得集合的size.只查询集合的size(count语句)
     */
    @Test
    public void fun3() {
        //1. 获得session
        Session session = HibernateUtils.getSession();
        //2. 开启事务并获得操作事务的对象
        Transaction tx = session.beginTransaction();
        //3. 执行操作
        
        Customer c = session.get(Customer.class, 2l);
        
        Set<LinkMan> linkMens = c.getLinkMens(); //关联级别
        
        System.out.println(linkMens.size());
        
        System.out.println(linkMens);
        
        
        //4. 提交事务并释放资源
        tx.commit();
        session.close();
        
    }
    /**
     * 集合级别的关联
     * fetch:join 使用多表查询加载集合数据
     * lazy:true|false|extra失效  立即加载
     */
    @Test
    public void fun4() {
        //1. 获得session
        Session session = HibernateUtils.getSession();
        //2. 开启事务并获得操作事务的对象
        Transaction tx = session.beginTransaction();
        //3. 执行操作
        
        Customer c = session.get(Customer.class, 2l);
        
        Set<LinkMan> linkMens = c.getLinkMens(); //关联级别
        
        System.out.println(linkMens.size());
        
        System.out.println(linkMens);
        
        
        //4. 提交事务并释放资源
        tx.commit();
        session.close();
        
    }
    /**
     * 集合级别的关联
     * fetch:subselect 使用子查询加载集合数据
     * lazy:true  延迟加载
     */
    @Test
    public void fun5() {
        //1. 获得session
        Session session = HibernateUtils.getSession();
        //2. 开启事务并获得操作事务的对象
        Transaction tx = session.beginTransaction();
        //3. 执行操作
        
        String hql = "from Customer";
        
        Query query = session.createQuery(hql);
        
        List<Customer> list = query.list();
        
        for(Customer c : list) {
            System.out.println(c.getLinkMens());
        }
        
        
        //4. 提交事务并释放资源
        tx.commit();
        session.close();
        
    }
    /**
     * 集合级别的关联
     * fetch:subselect 使用子查询加载集合数据
     * lazy:false  立即加载加载
     */
    @Test
    public void fun6() {
        //1. 获得session
        Session session = HibernateUtils.getSession();
        //2. 开启事务并获得操作事务的对象
        Transaction tx = session.beginTransaction();
        //3. 执行操作
        
        String hql = "from Customer";
        
        Query query = session.createQuery(hql);
        
        List<Customer> list = query.list();
        
        for(Customer c : list) {
            System.out.println(c.getLinkMens());
        }
           
        //4. 提交事务并释放资源
        tx.commit();
        session.close();
        
    }
    /**
     * 集合级别的关联
     * fetch:subselect 使用子查询加载集合数据
     * lazy:extra  极其懒惰加载
     */
    @Test
    public void fun7() {
        //1. 获得session
        Session session = HibernateUtils.getSession();
        //2. 开启事务并获得操作事务的对象
        Transaction tx = session.beginTransaction();
        //3. 执行操作
        
        String hql = "from Customer";
        
        Query query = session.createQuery(hql);
        
        List<Customer> list = query.list();
        
        for(Customer c : list) {
            System.out.println(c.getLinkMens().size());
            System.out.println(c.getLinkMens());
        }
        
        
        //4. 提交事务并释放资源
        tx.commit();
        session.close();
        
    }
}

　　  2. 关联属性策略     

　　   fetch属性 决定加载的sql语句
  　　　　select:使用单表查询
　　　　  join：使用多表查询
　　   lazy:决定加载时机
　　　　  false：立即加载
　　　　  proxy：有customer的类级别加载策略决定

         

/**
 * 
 *  关联级别  延迟加载
 *  属性策略
 * @author vanguard
 *
 */
public class Demo02 {
    /**
     * 
     * fetch:select  单表查询
     * lazy:proxy 
     *   Customer--true 
     */
    @Test
    public void fun1() {
        //1. 获得session
        Session session = HibernateUtils.getSession();
        //2. 开启事务并获得操作事务的对象
        Transaction tx = session.beginTransaction();
        //3. 执行操作
        
        LinkMan linkMan = session.get(LinkMan.class, 1l);
        
        Customer customer = linkMan.getCustomer();
        
        System.out.println(customer);
        
        //4. 提交事务并释放资源
        tx.commit();
        session.close();
        
    }
    /**
     * 
     * fetch:select  单表查询
     * lazy:proxy 
     *   Customer--false 立即加载 
     */
    @Test
    public void fun2() {
        //1. 获得session
        Session session = HibernateUtils.getSession();
        //2. 开启事务并获得操作事务的对象
        Transaction tx = session.beginTransaction();
        //3. 执行操作
        
        LinkMan linkMan = session.get(LinkMan.class, 1l);
        
        Customer customer = linkMan.getCustomer();
        
        System.out.println(customer);
        
        //4. 提交事务并释放资源
        tx.commit();
        session.close();
        
    }
    /**
     * 
     * fetch:join  多表查询
     * lazy:proxy 失效  都是立即加载
     */
    @Test
    public void fun3() {
        //1. 获得session
        Session session = HibernateUtils.getSession();
        //2. 开启事务并获得操作事务的对象
        Transaction tx = session.beginTransaction();
        //3. 执行操作
        
        LinkMan linkMan = session.get(LinkMan.class, 1l);
        
        Customer customer = linkMan.getCustomer();
        
        System.out.println(customer);
        
        //4. 提交事务并释放资源
        tx.commit();
        session.close();
        
    }
    
}

   结论:为了提高效率.fetch的选择上应选择select. lazy的取值应选择 true. 全部使用默认值.

     4. no-session问题解决：

       扩大session的作用域

         

 　　3）批量抓取

           betch-size:值是抓取集合的数量

          抓取客户的集合时，一次抓取集合客户的联系人

转载于:https://www.cnblogs.com/guodong-wang/p/7511304.html

diaogu9242
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Hibernate入门第一讲——Hibernate框架的快速入门
李阿昀的博客
08-04 12万+
Hibernate框架介绍什么是Hibernate我们可以从度娘上摘抄这样有关Hibernate的介绍： Hibernate是一个开放源代码的对象关系映射框架，它对JDBC进行了非常轻量级的对象封装，它将POJO与数据库表建立映射关系，是一个全自动的orm框架，hibernate可以自动生成SQL语句，自动执行，使得Java程序员可以随心所欲的使用对象编程思维来操纵数据库。Hibernate可以
Hibernate-Validator的学习
qq_461491877的博客
01-15 3943
hibernate-validator的学习 1.hibernate-validator介绍 早期的网站，用户输入一个邮箱地址，需要将邮箱地址发送到服务端，服务端进行校验，校验成功后，给前端一个响应。 有了JavaScript后，校验工作可以放在前端去执行。那么为什么还需要服务端校验呢？ 因为前端传来的数据不可信。前端很容易获取到后端的接口，如果有人直接调用接口，就可能会出现非法数据，所以服务端也要数据校验。 总的来说： 前端校验：主要是提高用户体验 后端校验：主要是保证数据安全可靠 校验参数基本上
带你逐步深入了解SSH框架——hibernate配置一对多和多对多
宇翔XGT的博客
11-30 503
） 今天内容 0 列表功能实现 1 表与表之间关系回顾 （1）一对多（客户和联系人） （2）多对多（用户和角色） 2 hibernate一对多操作 （1）一对多映射配置 （2）一对多级联保存 （3）一对多级联删除 （4）inverse属性 3 hibernate多对多操作 （1）多对多映射配置 （2）多对多级联保存（重点） （3）多对
学习Hibernate框架--框架搭建及简单使用
Ricartc的编程梦
10-30 2488
在学习Hibernate框架之前首先来了解一下什么是Hibernate框架以及为什么要使用它 Hibernate是 一个开源的对象关系映射框架 对JDBC进行了非常轻量级的对象封装 将JacaBean对象和数据库的表建立对应关系 它是一个优秀的Java持久化层解决方案 是当今主流的对象——关系映射工具 它简化了JDBC繁琐的编码，将数据库的连接信息都放置在配置文件中 来...
SpringBoot 项目中整合数据校验框架 hibernate-validator
华仔仔的博客
07-05 1646
早期的网站，用户输入一个邮箱地址，需要将邮箱地址发送到服务端，服务端进行校验，校验成功后再给前端一个响应。自从有了 JavaScript 后，校验工作可以放在前端去执行。那么为什么还需要服务端校验呢？因为前端传来的数据不可信，前端很容易获取到后端的接口，如果有人直接调用接口，就可能会出现非法数据，因此服务端也要数据校验。总的来说：校验参数基本上是一个体力活，而且冗余代码繁多，也影响代码的可读性，我们需要一个比较优雅的方式来解决这个问题。Hibernate Validator 框架刚好解决了这个问题，可以很优
Hibernate框架
weixin_43979868的博客
03-11 1493
Hibernate 轻量级、持久层、ORM，Hibernate 是一款全自动的 ORM 框架。 ORM ORM 是一种自动生成 SQL 语句的技术，它可以将对象中的数据自动存储到数据库中，也可以反过来将数据库中的数据自动提取到对象中，整个过程不需要人工干预，避免了手写 SQL 带来的麻烦 Object：对象 Relation：关系型数据库 Mapping：映射 Hibernate与MyBatis的比较 缓存机制 Hibernate 提供了缓存机制（一级缓存、二级缓存、查询缓存），我们可以将那些经常使用的
全面解析Hibernate框架--小白必看
zytdoit的博客
12-12 313
欢迎来到zyt.doit.com 哈哈，第一天给大家分享一个持久层框架—–HibernateHibernate, 语义冬眠 .与数据库打交道的框架 ，我们称之为持久层框架。介绍几个术语 持久 把内存中的对象保存到硬盘设备上加以固化。 持久用到的技术有：文件写入，jdbc操作数据库，orm映射操作数据库。 对象关系映射ORM 通过一个描述性文件，自动把对象持久化到数据库中。 Object R
JavaEE--------Hibernate框架
詹煜彪9527
03-21 4972
一. Hibernate 概述 Hibernate是一个开放源代码的对象关系映射框架，它对JDBC进行了非常轻量级的对象封装，它将POJO与数据库表建立映射关系，是一个全自动的orm框架，hibernate可以自动生成SQL语句，自动执行，使得Java程序员可以随心所欲的使用对象编程思维来操纵数据库。Hibernate可以应用在任何使用JDBC的场合，既可以在Java的客户端程序使用，也...
Hibernate框架--学习笔记（上）：hibernate项目的搭建和常用接口方法、对象的使用
张维鹏的博客
07-19 692
一、什么是Hibernate框架： 1.Hibernate是一个操作数据库的框架，实现了对JDBC的封装； 2.Hibernate是一个ORM（对象关系映射）框架，我们在写程序时 ，用的是面向对象的方法，但是在关系型数据库里，存的是一条条的数据，为了用纯面向对象的思想解决问题，所有需要将程序中的对象和数据库的记录建立起映射关系，ORM就是这样的技术，而Hibernate就是这样一个框架，以操作...
Java学习——Hibernate框架-01(第一天)
weixin_35908504的博客
08-11 175
一. 第一天 1. hibernate框架介绍和框架准备工作 1.1框架是什么？   框架用来提高开发效率的。  半成品项目   框架封装好了一些功能，我们需要使用这些功能时，调用即可，不需要再手动实现; 1.2 hibernate框架是什么？       三层架构：Web层（ Struts2框架（代替servlet）+ jsp ）                        Se...
hibernate-release-4.2.4.Final.zip
03-03
【标题】"Hibernate框架4.2.4.Final版本安装包" 【描述】"这个压缩文件包含的是Hibernate框架4.2.4.Final版本的相关组件，是开发人员在使用Hibernate进行Java应用程序开发时的重要资源。Hibernate是一个开源的对象...
hibernate-release-5.0.7.Final的所有jar包
05-28
4. **hibernate-validator**: Hibernate的验证框架，符合JSR-303/JSR-349标准，用于数据验证，确保输入数据的正确性。 5. **hibernate-c3p0**和**hibernate-ehcache**: 这两个是连接池和缓存服务的提供者，分别对应...
hibernate-release-5.2.10
08-22
4. **示例**：可能包含一些简单的示例项目，用于演示如何配置和使用Hibernate，对于初学者来说是非常实用的学习资源。 5. **构建脚本**：如pom.xml文件（如果使用Maven），或者build.gradle文件（如果使用Gradle），...
hibernate-release-4.3.8.Final
08-15
Hibernate 4.3.8.Final引入了第二级缓存，它可以跨会话存储数据，提高应用性能。同时，Hibernate还支持查询缓存，将查询结果缓存起来，避免重复执行SQL。 五、事务处理 Hibernate提供了基于JTA（Java Transaction ...
hibernate-release-5.2.16.Final.zip
04-16
一、Hibernate框架核心概念 1. **对象关系映射（ORM）**：Hibernate的核心功能就是通过ORM机制将Java对象与数据库表进行映射，实现了程序代码与数据库结构的解耦，提高了开发效率。 2. **配置文件**：Hibernate的...
配置Java开发环境
Broken_x的博客
07-10 1567
Java开发环境配置
java版的上门家政系统和PHP版的上门家政有什么区别？
最新发布
baina666的博客
07-12 528
综上所述，Java版和PHP版的上门家政系统各有优缺点，选择哪种语言主要取决于项目的具体需求、预算、开发团队的技术栈以及未来的扩展计划等因素。同时，由于Java生态系统的复杂性和多样性，也可能需要投入更多的时间和资源来学习和掌握相关的技术和工具。Java版：Java拥有庞大的生态系统和丰富的第三方库，这为家政系统的开发和扩展提供了强大的支持。Java版：由于Java的编译执行机制和高效的垃圾回收算法，Java版家政系统通常具有更高的运行效率和更好的性能表现，尤其是在处理高并发、大数据量等复杂场景时。
elk部署springboot
Chihirozy的博客
07-11 387
elk部署springboot。
Java方法练习-双色球彩票系统
T1798218285的博客
07-11 281
红色球号码从1-33中选择；蓝色球号码从1-16中选择。投注号码由6个红色球号码和1个蓝色球号码组成。三等奖 5+1 / 5+0 3000。四等奖4+1 / 4+0 200。六等奖1+1 / 1+0 5。一等奖6+1 1000w。二等奖6+0 500w。五等奖3+1 / 2+1。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值