侯侯侯先生
侯侯侯先生

Hibernate详解4（查询方式和抓取策略）

目录

  • Hibernate的查询方式
    • OID查询
    • 对象导航检索查询
    • ==HQL检索查询==
      • 简单查询
      • 别名查询
      • 条件查询
      • 投影查询
      • 排序查询
      • 分页查询
      • 分组统计查询
      • HQL的多表查询
    • ==QBC检索查询==
      • 简单查询
      • 条件查询
      • 分页查询
      • 统计查询
      • 离线条件查询
    • SQL检索查询
  • Hibernate的抓取策略
    • 延迟加载的概述
      • 什么是延迟加载
      • 延迟加载的分类
    • 抓取策略
      • 抓取策略的概述
      • set标签上的fetch和lazy的使用
        • 代码实现
      • many-to-one标签上的fecth和lazy的使用
        • 代码实现
    • 批量抓取
      • 什么是批量抓取
      • 获取一的一方的对象,批量抓取关联的多的一方的对象
      • 获取多的一方的对象,批量抓取关联一的一方的对象
      • 代码实现

Hibernate的查询方式

OID查询

利用对象的ID进行检索

  1. 使用get() 方法

Customer customer = session.get(Customer.class,1l);

  1. 使用load() 方法

Customer customer = session.load(Customer.class,1l);

对象导航检索查询

Hibernate根据已经查询出来的对象，获得其关联对象的一种查询方式。

Customer customer = session.get(Customer.class, 5l);
Set linkMans = customer.getLinkMans();

HQL检索查询

是一种面向对象化的查询语言，语法类似于SQL，通过session.createQuery(),接受一个HQL进行查询。

HQL的查询 查询的是对象 ：from Customer，
如果使用条件查询，from Customer where cust_id = ? ，cust_id是用的对象中的属性

简单查询

  @Test
    /**
     * HQL的简单查询
     */
    public void demo2() {
        Session session = HibernateUtils.getCurrentSession();
        Transaction tx = session.beginTransaction();
        // 简单的查询
        Query query = session.createQuery("from Customer");
        List<Customer> list = query.list();

        // sql中支持*号的写法：select * from cst_customer; 但是在HQL中不支持*号的写法。
        /*
         * Query query = session.createQuery("select * from Customer");// 报错
         * List list = query.list();
         */

        for (Customer customer : list) {
            System.out.println(customer);
        }
        tx.commit();
    }

别名查询

  @Test
    /**
     * 别名查询
     */
    public void demo3() {
        Session session = HibernateUtils.getCurrentSession();
        Transaction tx = session.beginTransaction();
        // 别名的查询
        /*
         * Query query = session.createQuery("from Customer c"); List
         * list = query.list();
         */

        Query query = session.createQuery("select c from Customer c");
        List<Customer> list = query.list();

        for (Customer customer : list) {
            System.out.println(customer);
        }
        tx.commit();
    }

条件查询

注意：设置条件时候，从 0 开始：query.setParameter(0,“aa”);

@Test
    /**
     * 条件查询
     */
    public void demo5() {
        Session session = HibernateUtils.getCurrentSession();
        Transaction tx = session.beginTransaction();
        // 条件的查询
        // 一、按位置绑定：根据参数的位置进行绑定。
        // 一个条件
        /*
         * Query query = session.createQuery("from Customer where cust_name = ?");
         * query.setParameter(0, "李兵");  是从0 开始的，PreporeStatement 中是以 1 开始的
         * List list = query.list();
         */

        // 多个条件
        /*
         * Query query = session.createQuery(
         * "from Customer where cust_source = ? and cust_name like ?");
         * query.setParameter(0, "小广告"); query.setParameter(1, "李%");
         * List list = query.list();
         */

        // 二、按名称绑定
        Query query = session.createQuery("from Customer where cust_source = :aaa and cust_name like :bbb");
        // 设置参数:
        query.setParameter("aaa", "朋友推荐");
        query.setParameter("bbb", "李%");
        List<Customer> list = query.list();

        for (Customer customer : list) {
            System.out.println(customer);
        }
        tx.commit();
    }

投影查询

 @Test
    /**
     * 投影查询
     */
    public void demo6() {
        Session session = HibernateUtils.getCurrentSession();
        Transaction tx = session.beginTransaction();

        // 投影查询
        // 单个属性
        /*
         * List list = session.createQuery("select c.cust_name from Customer c").list();
         * for (Object object : list) {
         *      System.out.println(object);
         *  }
         */

        // 多个属性:
        /*
         * List list = session.createQuery("select c.cust_name,c.cust_source from Customer c").list();
         * for(Object[] objects : list) {
         *      System.out.println(Arrays.toString(objects));
          *   }
         */

        // 查询多个属性，但是我想封装到对象中。
        List<Customer> list = session.createQuery("select new Customer(cust_name,cust_source) from Customer").list();
        for (Customer customer : list) {
            System.out.println(customer);
        }
        tx.commit();
    }
 
  
排序查询
 
  
@Test
    /**
     * 排序查询
     */
    public void demo4() {
        Session session = HibernateUtils.getCurrentSession();
        Transaction tx = session.beginTransaction();
        // 排序的查询
        // 默认情况
        // List list = session.createQuery("from Customer order bycust_id").list();
        // 设置降序排序 升序使用asc 降序使用desc
        List<Customer> list = session.createQuery("from Customer order by cust_id desc").list();

        for (Customer customer : list) {
            System.out.println(customer);
        }
        tx.commit();
    }

 
  
分页查询
 
  
@Test
    /**
     * 分页查询
     */
    public void demo7() {
        Session session = HibernateUtils.getCurrentSession();
        Transaction tx = session.beginTransaction();

        // 分页查询
        Query query = session.createQuery("from LinkMans");
        query.setFirstResult(5); //开始的位置
        query.setMaxResults(5);  //一页查询几个
        List<LinkMans> list = query.list();

        for (LinkMans LinkMans : list) {
            System.out.println(LinkMans);
        }
        tx.commit();
    }

 
  
分组统计查询
 
  
 @Test
    /**
     * 分组统计查询
     */
    public void demo8() {
        Session session = HibernateUtils.getCurrentSession();
        Transaction tx = session.beginTransaction();

        // 聚合函数的使用：count(),max(),min(),avg(),sum()
        Object object = session.createQuery("select count(*) from Customer").uniqueResult();
        System.out.println(object);
        // 分组统计：
        List<Object[]> list = session.createQuery("select cust_source,count(*) from Customer group by cust_source").list();
        for (Object[] objects : list) {
            System.out.println(Arrays.toString(objects));
        }
        tx.commit();
    }

 
  
HQL的多表查询
 
  
SQL的多表查询
 
  
     
   
  •  
    连接查询
     
    
       
     
    • 交叉连接 ：笛卡尔积
      •  
     
    • 内连接 
      
         
       
      • 隐式内连接 ：select * from A,B where A.id = B.id
        •  
       
      • 显示内连接 : select * from A inner join B on A.id=B.id
        •  
      
       
      •  
     
    • 外链接 
      
         
       
      • 左外连接：select * from A left (outer) join B on A.id=B.id
        •  
       
      • 右外连接：select * from A right (outer) join B on A.id = B.id
        •  
      
       
      •  
    
     
    •  
   
  •  
    子查询 …
     
    •  
  
 
  
HQL的多表查询
 
  
     
   
  • 连接查询 
    
       
     
    • 交叉连接 ：笛卡尔积
      •  
     
    • 内连接 
      
         
       
      • 隐式内连接 ：select * from A,B where A.id = B.id
        •  
       
      • 显示内连接 : select * from A inner join B on A.id=B.id
        •  
       
      • 迫切内连接
        •  
      
       
      •  
     
    • 外链接 
      
         
       
      • 左外连接：select * from A left (outer) join B on A.id=B.id
        •  
       
      • 右外连接：select * from A right (outer) join B on A.id = B.id
        •  
       
      • 迫切左外连接
        •  
      
       
      •  
    
     
    •  
  
 
  
 
  
@Test
    /**
     * HQL的多表查询
     */
    public void demo9() {
        Session session = HibernateUtils.getCurrentSession();
        Transaction tx = session.beginTransaction();
        // SQL:SELECT * FROM cst_customer c INNER JOIN cst_LinkMans l ON
        // c.cust_id = l.lkm_cust_id;
        // HQL:内连接 from Customer c inner join c.LinkManss
        /*
         * List list = session.createQuery(
         * "from Customer c inner join c.LinkManss").list(); for (Object[]
         * objects : list) { System.out.println(Arrays.toString(objects)); }
         */

        // HQL:迫切内连接 其实就在普通的内连接inner join后添加一个关键字fetch. from Customer c inner
        // join fetch c.LinkManss
        List<Customer> list = session.createQuery("select distinct c from Customer c inner join fetch c.LinkManss")
                .list();// 通知hibernate，将另一个对象的数据封装到该对象中

        for (Customer customer : list) {
            System.out.println(customer);
        }
        tx.commit();
    }

 
  
QBC检索查询
 
  
QBC查询：Query By Criteria，条件查询。是一种更加面向对象化的查询的方式。
 
  
简单查询
 
  
@Test
    /**
     * 简单的查询
     */
    public void demo1(){
        Session session = HibernateUtils.getCurrentSession();
        Transaction tx = session.beginTransaction();

        // 获得Criteria的对象
        Criteria criteria = session.createCriteria(Customer.class);
        List<Customer> list = criteria.list();

        for (Customer customer : list) {
            System.out.println(customer);
        }
        tx.commit();
    }

 
  
条件查询
 
  
 
   
加条件的时候默认的是and连接，如果想使用or ，这样写：criteria.add(Restrictions.or(Restrictions.like(“cust_name”, “李%”)));
 每添加一个条件，就是加一个and 拼接上条件
 
  
 
  
 
@Test
    /**
     * 条件查询
     */
    public void demo4(){
        Session session = HibernateUtils.getCurrentSession();
        Transaction tx = session.beginTransaction();

        // 条件查询
        Criteria criteria = session.createCriteria(Customer.class);
        // 设置条件:
        /**
         * =   eq
         * >   gt
         * >=  ge
         * <   lt
         * <=  le
         * <>  ne
         * like
         * in
         * and
         * or
         */
        //使用or
        criteria.add(Restrictions.or(Restrictions.eq("cust_source","制药"),Restrictions.eq("cust_source", "产品")));

        //默认使用and
        criteria.add(Restrictions.eq("cust_source", "产品"));
        criteria.add(Restrictions.or(Restrictions.like("cust_name", "张%")));
        List<Customer> list = criteria.list();
        for (Customer customer : list) {
            System.out.println(customer);
        }
        tx.commit();
    }


 
  
分页查询
 
  
@Test
    /**
     * 分页查询
     */
    public void demo3(){
        Session session = HibernateUtils.getCurrentSession();
        Transaction tx = session.beginTransaction();

        // 分页查询
        Criteria criteria = session.createCriteria(LinkMans.class);
        criteria.setFirstResult(10);
        criteria.setMaxResults(10);
        List<LinkMans> list = criteria.list();

        for (LinkMans LinkMans : list) {
            System.out.println(LinkMans);
        }
        tx.commit();
    }

 
  
统计查询
 
  
add :普通的条件。where后面条件
 addOrder :排序
 setProjection :聚合函数 和 group by having
 
  
@Test
    /**
     * 统计查询
     */
    public void demo5(){
        Session session = HibernateUtils.getCurrentSession();
        Transaction tx = session.beginTransaction();

        Criteria criteria = session.createCriteria(Customer.class);
        /**
         * add				:普通的条件。where后面条件
         * addOrder			:排序
         * setProjection	:聚合函数 和 group by having
         */
        criteria.setProjection(Projections.rowCount());
        Long num = (Long) criteria.uniqueResult();
        System.out.println(num);
        tx.commit();
    }


 
  
离线条件查询
 
  
 
   
用于当多个条件进行判断的时候，如果条件非常多，就可以使用离线查询，这是脱离session使用
 Hibernate详解4（查询方式和抓取策略）_第1张图片
 
  
 
  
 @Test
    /**
     * 离线条件查询
     */
    public void demo6(){
        DetachedCriteria detachedCriteria = DetachedCriteria.forClass(Customer.class);
        detachedCriteria.add(Restrictions.like("cust_name", "李%"));

        Session session = HibernateUtils.getCurrentSession();
        Transaction transaction = session.beginTransaction();

        Criteria criteria = detachedCriteria.getExecutableCriteria(session);
        List<Customer> list = criteria.list();
        for (Customer customer : list) {
            System.out.println(customer);
        }
        transaction.commit();
    }

 
  
SQL检索查询
 
  
@Test
	public void demo1(){
		Session session = HibernateUtils.getCurrentSession();
		Transaction tx = session.beginTransaction();
		
		/*SQLQuery sqlQuery = session.createSQLQuery("select * from cst_customer");
		List list = sqlQuery.list();
		for (Object[] objects : list) {
			System.out.println(Arrays.toString(objects));
		}*/
		
		SQLQuery sqlQuery = session.createSQLQuery("select * from cst_customer");
		//添加实体，将查询出来的数据封装到实体中去
		sqlQuery.addEntity(Customer.class);
		List<Customer> list = sqlQuery.list();
		for (Customer customer : list) {
			System.out.println(customer);
		}
		tx.commit();
	}

 
  
Hibernate的抓取策略
 
  
延迟加载的概述
 
  
什么是延迟加载
 
  
 
   
延迟加载：lazy（懒加载），就是当查询到该行代码的时候，不会立即执行SQL语句，而是当用到该对象属性的时候，才会发送SQL语句进行查询。
 例如：Customer cus = session.load(Customer.class,1l); ,当执行到这行代码的时候，不会立即发送sql语句，而是当使用他的时候 customer.getCust_name();才会发送sql语句。
 使用customer.getCust_name();则不会发送sql语句，因为id是已知的。
 
  
 
  
延迟加载的分类
 
  
     
   
  • 类级别的延迟加载 
    
       
     
    • 指的是使用load()方法查询某个对象的时候，是否采用延迟加载， session.load(Customer.class,1l);
      •  
     
    • 类级别的延迟加载使用标签上的lazy属性进行配置的，lazy默认值为true，如何使lazy失效 
      
         
       
      • 将lazy的值改为false
        •  
       
      • 将持久化类用final修饰
        •  
       
      • Hibernate.Initialize()
        •  
      
       
      •  
    
     
    •  
   
  • 关联级别的延迟加载 
    
       
     
    •  
      关联级别的加载：当查询出一个对象的时候，通过该对象去查询其关联对象，是否采用延迟加载
       
      •  
     
    •  
      Customer customer = session.get(Customer.class,1l);
       customer.getLinkMans();----通过客户获得联系人的时候，联系人对象是否采用了延迟加载，称为是关联级别的延迟。
       
        关联级别的加载往往和抓取策略一起使用，优化语句

       
      •  
    
     
    •  
  
 
  
抓取策略
 
  
抓取策略的概述
 
  
 
   
通过一个对象获得其关联对象在抓取的时候需要发送SQL语句，采用什么样格式的SQL语？SQL语句如何发送？
 
   
     
    
  1. 通过set标签或者many-to-one标签上的fetchsh属性的值进行设置
     fetch属性作用是发送什么格式的sql语句，而lazy属性的作用是什么时候发送sql语句
    2.  
    
  2. fetch和这些标签上的lazy如何设置优化发送的SQL语句？？？
    3.  
   
 
  
 
  
set标签上的fetch和lazy的使用
 
  
查询到一的一方的对象，去关联查询多的一方的对象
 
  
     
   
  • fetch：抓取策略，控制SQL语句的格式 
    
       
     
    • select：默认值，发送正常形式的sql语句，查询关联对象
      •  
     
    • join：发送采取 迫切左外连接形式的sql语句，查询关联对象
      •  
     
    • subselect：发送采取子查询形式的sql语句，查询关联对象
      •  
    
     
    •  
   
  • lazy：延迟加载，控制查询其关联对象的时候，是否采用延迟加载（SQL语句什么时候进行发送）。 
    
       
     
    • true：默认值，查询关联对象的时候，采用延迟加载
      •  
     
    • false：查询关联对象的时候，不采用延迟加载
      •  
     
    • extra：及其懒惰加载（与延迟加载发送的sql语句不一样）
      •  
    
     
    •  
  
 
  
在实际开发中，一般都采用默认值。如果有特殊要求，采用join
 
  
 
   
fetch：select --------------------- lazy：true
 fetch：select --------------------- lazy：false
 fetch：select --------------------- lazy：extra
 fetch：join --------------------- lazy：失效，在查询客户的时候，采用左外连接，直接就把联系人查出来了
 fetch：subselect--------------------- lazy：true
 fetch：subselect--------------------- lazy：false
 fetch：subselect--------------------- lazy：extra
 
  
 
  
代码实现
 
  
package com.day04;

import com.utils.HibernateUtils;
import org.hibernate.Session;
import org.hibernate.Transaction;
import org.junit.Test;

import java.util.List;

/**
 * 在上的fetch和lazy
 * 根据客户查询客户的联系人，在一 的一方（客户）的 标签上设置
 */
public class HibernateDemo5 {

    @Test
    /**
     * 默认情况：
     */
    public void demo1(){
        Session session = HibernateUtils.getCurrentSession();
        Transaction tx = session.beginTransaction();

        // 查询5号客户
        Customer customer = session.get(Customer.class, 5l);// 发送一条查询客户的SQL
        System.out.println(customer.getCust_name());
        // 查看1号客户的每个联系人的信息
        for (LinkMans LinkMans : customer.getLinkMans()) {// 发送一条根据客户ID查询联系人的SQL
            System.out.println(LinkMans.getLkm_name());
        }
        tx.commit();
    }

    @Test
    /**
     * 设置fetch="select" lazy="true"
     */
    public void demo2(){
        Session session = HibernateUtils.getCurrentSession();
        Transaction tx = session.beginTransaction();

        // 查询1号客户
        Customer customer = session.get(Customer.class, 5l);// 发送一条查询客户的SQL
        System.out.println(customer.getCust_name());
        // 查看1号客户的每个联系人的信息
        for (LinkMans LinkMans : customer.getLinkMans()) {// 发送一条根据客户ID查询联系人的SQL
            System.out.println(LinkMans.getLkm_name());
        }
        tx.commit();
    }

    @Test
    /**
     * 设置	fetch="select" lazy="false"
     */
    public void demo3(){
        Session session = HibernateUtils.getCurrentSession();
        Transaction tx = session.beginTransaction();

        // 查询5号客户
        Customer customer = session.get(Customer.class, 5l);// 发送两条SQL语句：查询客户的名称，查询客户关联联系人
        System.out.println(customer.getCust_name());
		// 查看1号客户的每个联系人的信息
//		for (LinkMans LinkMans : customer.getLinkMans()) {//
//			System.out.println(LinkMans.getLkm_name());
//		}

        System.out.println(customer.getLinkMans().size());
        tx.commit();
    }

    @Test
    /**
     * 设置fetch="select" lazy="extra"
     */
    public void demo4(){
        Session session = HibernateUtils.getCurrentSession();
        Transaction tx = session.beginTransaction();

        // 查询5号客户
        Customer customer = session.get(Customer.class, 5l);// 发送一条查询1号客户的SQL语句
        System.out.println(customer.getCust_name());

        System.out.println(customer.getLinkMans().size());// 发送一条select count() from ...;
        tx.commit();
    }

    @Test
    /**
     * 设置fetch="join" lazy=失效
     */
    public void demo5(){
        Session session = HibernateUtils.getCurrentSession();
        Transaction tx = session.beginTransaction();

        // 查询1号客户
        Customer customer = session.get(Customer.class, 1l);// 发送一条迫切左外连接查询记录
        System.out.println(customer.getCust_name());

        System.out.println(customer.getLinkMans().size());// 不发送
        tx.commit();
    }

    @SuppressWarnings("unchecked")
    @Test
    /**
     * 设置fetch="subselect" lazy="true"
     */
    public void demo6(){
        Session session = HibernateUtils.getCurrentSession();
        Transaction tx = session.beginTransaction();

        List<Customer> list = session.createQuery("from Customer").list();// 发送查询所有客户的SQL
        for (Customer customer : list) {
            System.out.println(customer.getCust_name());
            System.out.println(customer.getLinkMans().size());// 发送一条子查询
        }

        tx.commit();
    }

    @SuppressWarnings("unchecked")
    @Test
    /**
     * 设置fetch="subselect" lazy="false"
     */
    public void demo7(){
        Session session = HibernateUtils.getCurrentSession();
        Transaction tx = session.beginTransaction();

        List<Customer> list = session.createQuery("from Customer").list();// 发送查询所有客户的SQL，发送一条子查询
        for (Customer customer : list) {
            System.out.println(customer.getCust_name());
            System.out.println(customer.getLinkMans().size());//
        }

        tx.commit();
    }
}


 
  
many-to-one标签上的fecth和lazy的使用
 
  
查询到多的一方的对象，去关联查询一的一方的对象
 
  
     
   
  •  
    fetch：抓取策略，控制SQL语句的格式
     
    
       
     
    • select：默认值，发送正常形式的sql语句，查询关联对象
      •  
     
    • join：发送采取 迫切左外连接形式的sql语句，查询关联对象
      •  
    
     
    •  
   
  •  
    lazy：延迟加载，控制查询其关联对象的时候，是否采用延迟加载（SQL语句什么时候进行发送）。
     
    
       
     
    • proxy：默认值，proxy具体的取值，取决于另一端的class标签上的lazy的值。class标签上lazy的值是什么，proxy就表示什么
      •  
     
    • false：查询关联对象的时候，不采用延迟加载
      •  
     
    • no-proxy：不会使用
      •  
    
     
    •  
  
 
  
 
   
fetch：select --------------------- lazy：proxy
 fetch：select --------------------- lazy：false
 fetch：join --------------------- lazy：失效，在查询客户的时候，采用左外连接，直接就把联系人查出来了
 
  
 
  
代码实现
 
  
package com.day04;

import com.utils.HibernateUtils;
import org.hibernate.Session;
import org.hibernate.Transaction;
import org.junit.Test;

/**
 * many-to-one上的fetch和lazy测试
 *
 */
public class HIbernateDemo6 {
    @Test
    /**
     * 默认值
     */
    public void demo1(){
        Session session = HibernateUtils.getCurrentSession();
        Transaction tx = session.beginTransaction();

        LinkMans LinkMans = session.get(LinkMans.class, 1l);// 发送一条查询联系人语句
        System.out.println(LinkMans.getLkm_name());
        System.out.println(LinkMans.getCustomer().getCust_name());// 发送一条select语句查询联系人所关联的客户

        tx.commit();
    }

    @Test
    /**
     * fetch="select" lazy="proxy"
     */
    public void demo2(){
        Session session = HibernateUtils.getCurrentSession();
        Transaction tx = session.beginTransaction();

        LinkMans LinkMans = session.get(LinkMans.class, 1l);// 发送一条查询联系人语句
        System.out.println(LinkMans.getLkm_name());
        System.out.println(LinkMans.getCustomer().getCust_name());// 发送一条select语句查询联系人所关联的客户

        tx.commit();
    }

    @Test
    /**
     * fetch="select" lazy="false"
     */
    public void demo3(){
        Session session = HibernateUtils.getCurrentSession();
        Transaction tx = session.beginTransaction();

        LinkMans LinkMans = session.get(LinkMans.class, 1l);// 发送一条查询联系人语句,发送一条select语句查询联系人所关联的客户
        System.out.println(LinkMans.getLkm_name());
        System.out.println(LinkMans.getCustomer().getCust_name());// 

        tx.commit();
    }

    @Test
    /**
     * fetch="join" lazy=失效
     */
    public void demo4(){
        Session session = HibernateUtils.getCurrentSession();
        Transaction tx = session.beginTransaction();

        LinkMans LinkMans = session.get(LinkMans.class, 1l);// 发送一条迫切左外连接查询联系人所关联的客户。
        System.out.println(LinkMans.getLkm_name());
        System.out.println(LinkMans.getCustomer().getCust_name());// 

        tx.commit();
    }
}


 
  
批量抓取
 
  
什么是批量抓取
 
  
批量抓取就是批量抓取多个关联对象 ,使用属性batch-size=“3”,表示批量抓取一次抓取3个关联对象.
 
  
获取一的一方的对象,批量抓取关联的多的一方的对象
 
  
在一的一方的xml配置文件中的set标签上配置batch-size属性,默认值是1.
 批量抓取,sql语句发送的格式和发送的时候是否使用延迟加载,使用fecth和lazy默认的值就可以.
 batch-size只是表示在抓取的时候抓取多个,控制抓取关联对象的个数.
 
  
获取多的一方的对象,批量抓取关联一的一方的对象
 
  
在一的xml配置文件中的class属性上,配置batch-size属性的值,而不是在多的一方的xml配置文件上的many-to-one标签上去设置batch-size的值,标签上也没有该属性.
 
  
代码实现
 
  
package com.day04;


import com.utils.HibernateUtils;
import org.hibernate.Session;
import org.hibernate.Transaction;
import org.junit.Test;

import java.util.List;

/**
 * 批量抓取
 *
 */
public class HibernateDemo7 {

    @SuppressWarnings("unchecked")
    @Test
    /**
     * 获取客户的时候，批量抓取联系人
     * 在Customer.hbm.xml中set上配置batch-size
     */
    public void demo1(){
        Session session = HibernateUtils.getCurrentSession();
        Transaction tx = session.beginTransaction();

        List<Customer> list = session.createQuery("from Customer").list();
        for (Customer customer : list) {
            System.out.println(customer.getCust_name());
            for (LinkMans LinkMans : customer.getLinkMans()) {
                System.out.println(LinkMans.getLkm_name());
            }
        }
        tx.commit();
    }

    @SuppressWarnings("unchecked")
    @Test
    /**
     * 获取联系人的时候，批量抓取客户
     * * 在Customer.hbm.xml中上配置
     */
    public void demo2(){
        Session session = HibernateUtils.getCurrentSession();
        Transaction tx = session.beginTransaction();

        List<LinkMans> list = session.createQuery("from LinkMans").list();
        for (LinkMans LinkMans : list) {
            System.out.println(LinkMans.getLkm_name());
            System.out.println(LinkMans.getCustomer().getCust_name());
        }
        tx.commit();
    }
}



 
  

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(框架篇)

        

            

                
    
                    
  • 高级java每日一道面试题-2025年01月24日-框架篇[SpringBoot篇]-如何理解 Spring Boot 中的 Starters(启动器) ?
                        java我跟你拼了
java每日一道面试题javaspringboot简化依赖管理自动配置加快开发速度自动管理依赖项简化外部化配置
                        
    如果有遗漏,评论区告诉我进行补充面试官:如何理解SpringBoot中的Starters(启动器)?我回答:一、Starters的定义与作用1.定义Starters是SpringBoot中的一组预定义依赖关系，这些依赖被封装在一个单一的包中。它们简化了Maven或Gradle配置文件中的依赖项声明，并自动配置和管理相关依赖项。2.作用简化依赖管理：通过引入一个starter，可以自动引入所有必要的
    
                    
    • 
                    
  • 高级java每日一道面试题-2025年01月19日-框架篇[Mybatis篇]-MyBatis 中见过什么设计模式 ?
                        java我跟你拼了
java每日一道面试题javamybatis设计模式
                        
    如果有遗漏,评论区告诉我进行补充面试官:MyBatis中见过什么设计模式?我回答:1.工厂模式（FactoryPattern）定义：工厂模式是一种创建型模式，它提供了一种创建对象的最佳方式，将对象创建过程抽象化，从而提高代码的可维护性和灵活性。在MyBatis中的应用：SqlSessionFactoryBuilder和SqlSessionFactory的创建过程体现了工厂模式的应用。SqlSess
    
                    
    • 
                    
  • 高级java每日一道面试题-2025年01月16日-框架篇[Mybatis篇]-说说Mybatis的缓存机制?
                        java我跟你拼了
java每日一道面试题javamybatis缓存一级缓存二级缓存工作原理全局配置
                        
    如果有遗漏,评论区告诉我进行补充面试官:说说Mybatis的缓存机制?我回答:在Java高级面试中，MyBatis的缓存机制是一个重要的话题。MyBatis是一个流行的Java持久化框架，它提供了强大的数据库访问能力和灵活的SQL映射配置。为了提高查询性能并减少数据库访问次数，MyBatis引入了缓存机制。下面将对MyBatis的缓存机制进行详细解释：MyBatis缓存机制概述MyBatis的缓存
    
                    
    • 
                    
  • Python Web 框架篇：Flask、Django、FastAPI介绍及其核心技术
                        Switch616
PythonWebpython前端flaskfastapidjango开发语言后端
                        
    PythonWeb框架篇：Flask、Django、FastAPI介绍及其核心技术目录FlaskFlask核心概念（路由、视图函数、模板渲染）FlaskBlueprint模块化应用Flask扩展（Flask-SQLAlchemy、Flask-WTF、Flask-Migrate等）DjangoDjango项目架构DjangoORM及模型定义Django中间件Django信号机制DjangoForm和
    
                    
    • 
                    
  • 12306项目学习笔记（框架篇Base）
                        Rainyocode
学习
                        
    首先学习的是基础框架ApplicationContextHolderApplicationContextHolder提供了一种静态方式来访问Spring容器中的Bean，适用于某些特定场景，如工具类和框架集成。在12306项目中由于我们引入了RocketMQ消息队列，这些库的对象通常不是Spring管理的，无法直接使用@Autowired注入，所以需要ApplicationContextHolde
    
                    
    • 
                    
  • java3-5年面试题——框架篇
                        若久2023
javaspring
                        
    -----Spring------1.springIOC的理解springioc指的是控制反转，IOC容器负责实例化、定位、配置应用程序中的对象及建立这些对象间的依赖。交由Spring容器统一进行管理，从而实现松耦合注入对象：构造方法注入、stter方法注入、接口注入2.spring是如何通过xml配置或者注解配置生成实例对象的？简单实列：将对象放入SpringIOC容器中。1.配置文件方式：ap
    
                    
    • 
                    
  • 高级java每日一道面试题-2024年8月27日-框架篇[SpringMVC篇]-Spring MVC 支持哪些视图技术?
                        java我跟你拼了
java每日一道面试题javaspringmvc框架篇SpringMVC篇后端视图解析器
                        
    如果有遗漏,评论区告诉我进行补充面试官:SpringMVC支持哪些视图技术?我回答:SpringMVC作为基于Spring框架的Web应用开发框架，其核心优势之一在于其支持多种视图技术，这使得开发者可以根据项目需求或个人偏好选择最适合的视图渲染方式。以下是SpringMVC支持的一些主要视图技术：JSP（JavaServerPages）：JSP是JavaEE规范的一部分，是Java平台下最常用的视
    
                    
    • 
                    
  • 高级java每日一道面试题-2024年8月24日-框架篇[Spring篇]-Spring Bean 的作用域之间有什么区别?
                        java我跟你拼了
java每日一道面试题java框架篇[Spring篇]Spring框架作用域单例原型
                        
    如果有遗漏,评论区告诉我进行补充面试官:SpringBean的作用域之间有什么区别?我回答:在Spring框架中，Bean的作用域（Scope）定义了Bean的生命周期和可见性。Spring提供了几种不同的作用域，每种作用域都适用于不同的场景和需求。以下是SpringBean中常见的作用域及其之间的区别：singleton（单例）描述:singleton是Spring默认的作用域。定义：当一个Be
    
                    
    • 
                    
  • 高级java每日一道面试题-2024年8月22日-框架篇-IOC容器的一些具体的实现有哪些?
                        java我跟你拼了
java每日一道面试题IOC容器框架篇IOC容器实现SpringFrameworkGoogleGuiceWeldPicoContainer
                        
    如果有遗漏,评论区告诉我进行补充面试官:IOC容器的一些具体的实现有哪些?我回答:在Java中，控制反转（InversionofControl,IoC）是一种设计原则，用于减少代码间的耦合。IoC容器是实现IoC原则的一种工具，它负责管理对象之间的依赖关系，而不是由代码直接控制。在Java生态中，IoC容器主要通过依赖注入（DependencyInjection,DI）的方式来实现。以下是一些Ja
    
                    
    • 
                    
  • web框架篇--基础
                        shitou987
测试开发djangopythonweb框架
                        
    1.什么是框架框架，即framework,特指为解决一个开放性问题而设计的具有一定约束性的支撑结构，使用框架可以帮你快速开发特定的系统，简单地说，就是你用别人搭建好的舞台来做表演。对于所有的Web应用，本质上其实就是一个socket服务端，用户的浏览器其实就是一个socket客户端1.浏览器发送一个http请求2.服务器接收到请求，生成一个html文档3.服务器把http文档作为http响应的bo
    
                    
    • 
                    
  • 高频面试真题答案 -java后端 -java框架篇
                        qq_46529610
高频面试真题答案-java后端java面试后端
                        
    原贴：2022届秋招高频面试真题汇总，千题奉送！！！-后端篇_笔经面经_牛客网整理答案：SpringAOP的底层原理51SpringBean的生命周期31Spring中IOC的底层原理28Spring如何解决循环依赖22spring的动态代理模式14Spring使用了哪些设计模式？9springioc的设计思想和好处8简述为什么要使用Spring？(Spring优势)6简述Spring事务6spr
    
                    
    • 
                    
  • Java框架篇-Heibernate(一)
                        TianTianBaby223

                        
    一:简述Hibernate框架是当今主流的Java持久层框架之一,简单易学,灵活,扩展性强,能够大大地简化程序的代码量,提高工作效率,受到广大开发人员喜爱.Heibernate是一个快放源代码的ORM(ObjectRelationalMapping,对象关系映射)它对JDBC进行了轻量级的对象封装,使得开发人员可以使用面向对象的编程思维来操作数据库二:解压包结构结构documentation:存放
    
                    
    • 
                    
  • 京东技术负责人纯手写：小团队构建大网站中小研发团队架构实战
                        Java爱好者

                        
    本书结合作者近几年的工作经验，总结了一套可直接落地、基于开源、成本低、可快速搭建的中小研发团队架构实践方法。本书共5篇22章，开篇是本书的导读;架构篇是设计思想的提升，包括企业总体架构、应用架构设计、统--应用分层等;框架篇主讲中间件和工具的使用，包括消息队列、缓存、Job、集中式日志、应用监控和微服务等:公共应用篇是技术与业务的结合，包括单点登录和企业支付网关:进阶篇是从架构到管理，包括技改案例
    
                    
    • 
                    
  • 知识点积累
                        格桑阿sir
云原生学习专栏go容器kubernetes云原生devops
                        
    云原生学习路线导航页（持续更新中）知识点积累本文主要记录日常学习中遇到的疑难知识点随着知识点积累内容变多，本文越来越长，不方便阅读，故将本文拆成多篇文章，目录如下本文不再更新，更多内容请按照下面的目录进行查看知识点积累系列（一）golang语言篇【持续更新】知识点积累系列（二）数据库篇【持续更新】知识点积累系列（三）golang框架篇【持续更新】知识点积累系列（四）Kubernetes篇【持续更新
    
                    
    • 
                    
  • 知识点积累系列（三）golang框架篇【持续更新】
                        格桑阿sir
云原生学习专栏golang开发语言后端gin云原生devops
                        
    云原生学习路线导航页（持续更新中）本文是知识点积累系列文章的第三篇，记录日常学习中遇到的golang框架相关的知识点1、gin框架相关1.1.在gin中间件中直接return，相当于什么在Gin中间件中直接使用return语句，相当于提前结束当前中间件的执行，并将控制权返回给请求处理链的下一个中间件或处理函数。这意味着后续的中间件或处理函数将不会被执行。
    
                    
    • 
                    
  • 【sylar】框架篇-Chapter13-http 模块
                        江湖人称菠萝包
【C++】服务器编程-实战linux服务器c++
                        
    站在巨人的肩膀上C++高性能分布式服务器框架从零开始重写sylarC++高性能分布式服务器框架概述对http协议的封装。http.hhttp定义结构体封装模块。一些方法描述和错误码定义是直接拷贝自以下地址：https://github.com/nodejs/http-parser/blob/main/http_parser.hHttpMethodhttp方法枚举类。利用了拷贝回来的宏定义。Http
    
                    
    • 
                    
  • 【sylar】框架篇-Chapter1-搭建开发环境
                        江湖人称菠萝包
【C++】服务器编程-实战linux服务器c++
                        
    站在巨人的肩膀上C++高性能分布式服务器框架从零开始重写sylarC++高性能分布式服务器框架安装虚拟机-下载镜像-CentOS7.6-CentOS-7-x86_64-Minimal-1810.iso-一路next即可-安装后查看ip地址以便于连接ssh：$ipaddr切换root用户-输入su时候如果有鉴定故障，则$sudopasswdroot输入新的密码$su输入密码即可创建存放软件包的目录#
    
                    
    • 
                    
  • JavaEE--框架篇（1）Spring
                        i18n486
javaspringiocaop
                        
    目录前言框架篇（1）SpringIOC实现原理自定义实现简单的IOCSpring中的IOCSpringIOC相关知识梳理***：Scope的取值范围以及各自的含义***：@Autowired注解的搜索规则是什么？AOP实现原理自定义实现简单的AOPSpring中的AOP***：切点，切面，前置通知、环绕通知等是什么？***：要想实现事务控制，为什么必须接管Dao实例以及数据库连接池实例？前言带着问
    
                    
    • 
                    
  • Java框架篇面试题
                        过去日记
java面试题java开发语言
                        
    作者简介：过去日记，致力于Java、GoLang,Rust等多种编程语言，热爱技术，喜欢游戏的博主。本文收录于java面试题系列，大家有兴趣的可以看一看相关专栏Rust初阶教程、go语言基础系列、spring教程等，大家有兴趣的可以看一看Java并发编程系列，设计模式系列、goweb开发框架系列正在发展中，喜欢Java，GoLang，Rust，的朋友们可以关注一下哦！文章目录Spring框架中的单
    
                    
    • 
                    
  • 微前端框架篇一，了解qiankun
                        Dormiveglia-flx
前端框架前端vuevue.js
                        
    微前端框架篇一，了解qiankun①前置知识补充Ⅰ什么是微前端？Ⅱ什么是JSCSS沙箱？Ⅲ什么是spa单页面应用？ⅣSystemJS与import-html-entryⅤ现有的微前端方案②了解single-spa微前端框架③了解qiankun框架①前置知识补充Ⅰ什么是微前端？微前端是一种将复杂单体应用拆分为多个小型独立前端应用，然后将这些小应用按需加载并集成到主应用的技术方案。每个子应用都有自己的
    
                    
    • 
                    
  • 2024前端年末备战面试总结——框架篇(Vue)
                        聪明的竹子
前端面试vue.js
                        
    框架篇（Vue）本文是本人根据Vue官网上的内容或者网上一些其他朋友的文章以及自己的理解，整理归纳出来的一篇Vue方面的面试题及知识点，其中不免有许多漏掉的问题或是答案，发现错误的或者是有什么问题需要补充的朋友们，可以在评论区留言，大家虚心交流，一起进步。1.Vue是什么Vue是一款基于MVVM架构的渐进式框架，它主要用于构建单页面应用（spa），它的特点有声明式渲染、响应式两大点。（1）什么是M
    
                    
    • 
                    
  • 【SpringBoot框架篇】32.基于注解+redis实现表单防重复提交
                        皓亮君
springBootspringbootredisjava
                        
    文章目录1.简介2.后端防表单重复提交设计实现2.1.引入依赖2.2.添加redis配置2.3.添加需要使用的工具类2.4.添加防重复提交注解2.5.使用Aop实现限流逻辑3.测试3.1.添加需要限流的接口3.2.模拟表单重复提交操作4.项目配套代码1.简介在一些表单提交操作的时候会存在用户多次点击button触发提交事件的场景(针对异步请求场景)。在客户端可以针对重复提交添加状态值判断,如下:1
    
                    
    • 
                    
  • 【SpringBoot框架篇】30.使用sharding-jdbc实现读写分离和分库分表
                        皓亮君
springBootspringbootjava
                        
    文章目录1.简介2.引入依赖3.测试用到的类4.读写分类配置5.分库分表配置6.分库配置7.分表配置8.项目配套代码1.简介ShardingSphere-JDBC定位为轻量级Java框架，在Java的JDBC层提供的额外服务。它使用客户端直连数据库，以jar包形式提供服务，无需额外部署和依赖，可理解为增强版的JDBC驱动，完全兼容JDBC和各种ORM框架。适用于任何基于JDBC的ORM框架，如：J
    
                    
    • 
                    
  • 【SpringBoot框架篇】31.基于分布式锁或xxx-job实现分布式任务调度
                        皓亮君
springBootspringboot分布式java
                        
    文章目录1.简介2.分布式锁实现2.1.引用依赖2.2.定义分布式锁注解2.3.配置切入点和获取锁释放锁逻辑2.4.测试任务3.使用分布式任务调度平台xxx-job3.1.下载源码并运行项目3.2.springBoot项目集成xxl-job4.项目配套代码1.简介定时任务使用场景一般为指定时间做数据统计,临时数据清理等等。单节点部署的服务一般是通过下面方式实现即可:在SpringBoot启动类上面
    
                    
    • 
                    
  • 【SpringBoot框架篇】29.Jpa+vue实现单模型的低代码平台
                        皓亮君
springBootspringbootvue.js低代码
                        
    文章目录1.低代码平台概念2.最终效果图2.1.元数据模型页面2.2.通用数据页面3.代码实现3.1.后台3.2.前端4.项目配套代码1.低代码平台概念快速生成应用程序的开发平台低代码开发平台（LCDP）是无需编码（0代码）或通过少量代码就可以快速生成应用程序的开发平台。通过可视化进行应用程序开发的方法（参考可视编程语言），使具有不同经验水平的开发人员可以通过图形化的用户界面，使用拖拽组件和模型驱
    
                    
    • 
                    
  • 【SpringBoot框架篇】28.使用JdbcTemplate操作数据库
                        皓亮君
springBootspringboot数据库java
                        
    文章目录1.引入依赖2.配置数据集连接信息3.操作数据库3.1.执行DDL语句3.2.添加数据3.3.查询数据3.4.修改数据3.5.删除数据4.项目配套代码1.引入依赖org.springframework.bootspring-boot-starter-jdbcmysqlmysql-connector-java8.0.112.配置数据集连接信息spring:datasource:usernam
    
                    
    • 
                    
  • 【SpringBoot框架篇】24.集成FastDFS实现文件的分布式存储
                        皓亮君
springBootjavaspringbootrestful
                        
    文章目录1.简介2.添加配置2.1.在maven的pom.xml中添加fastDfs依赖包2.2.修改应用配置文件3.添加工具类4.测试接口编写5.测试5.1.上传图片5.2.下载图片5.3.删除图片6.项目配套代码1.简介如果应用是在集群部署,如果文件存储需要共享要通过linux的nfs服务来实现共享，或者把文件存储在分布式文件存储系统里面,例如FastDFS,minio,本章讲解集成FastD
    
                    
    • 
                    
  • 【SpringBoot框架篇】25.集成Minio实现文件的分布式对象存储
                        皓亮君
springBootspringbootlinux后端分布式
                        
    文章目录1.简介2.安装使用2.1.下载二进制文件安装2.1.1单机部署2.1.2.集群安装2.1.2.1创建存储路径2.1.2.2.创建集群启动脚本2.1.2.3.分别启动4个节点2.2.使用docker安装3.实战3.1.引入依赖3.2.配置Minio连接信息3.3.编辑Minio配置类3.4编写Mino工具类3.5.测试接口4.测试4.1.上传文件4.2.下载文件4.3.删除文件5.设置桶里
    
                    
    • 
                    
  • 【SpringBoot框架篇】26.集成spring-boot-starter-validation对接口参数校验
                        皓亮君
springBootspringbootspringjava
                        
    文章目录1.常规验证2.使用validation验证2.1.添加依赖2.2.常用注解2.3.在pojo类中添加需要使用的注解2.4.在接口入参处添加@Valid2.5.添加全局异常处理类返回校验错位提示信息3.项目配套代码1.常规验证以下面的登录接口为例,需要手动去验证参数是否存在,这种写法繁琐且不太优雅。@RestControllerpublicclassLoginController{@Req
    
                    
    • 
                    
  • 【SpringBoot框架篇】23.集成smart-doc插件零侵入自动生成RESTful格式API文档
                        皓亮君
springBootrestfuljavaspringboot
                        
    文章目录1.简介2.配置准备2.1添加maven插件2.2创建配置文件2.3添加统一返回数据格式类3.接口实战3.1demo接口类3.2用户模型类3.3相关注释描述4.文档生成并查看4.1生成文档命令4.2查看5.集成torna统一管理和测试API文档5.1创建空间并找到3要素(appKey,secret,appToken)5.2在smart-doc.json中添加三要素5.3推送文档到torna
    
                    
    • 
                                
  • Spring4.1新特性——Spring MVC增强
                                    jinnianshilongnian
spring 4.1
                                    
    目录 
Spring4.1新特性——综述 
Spring4.1新特性——Spring核心部分及其他 
Spring4.1新特性——Spring缓存框架增强 
Spring4.1新特性——异步调用和事件机制的异常处理 
Spring4.1新特性——数据库集成测试脚本初始化 
Spring4.1新特性——Spring MVC增强 
Spring4.1新特性——页面自动化测试框架Spring MVC T
    
                                
    • 
                                
  • mysql 性能查询优化
                                    annan211
javasql优化mysql应用服务器
                                    
    

1 时间到底花在哪了？
  mysql在执行查询的时候需要执行一系列的子任务，这些子任务包含了整个查询周期最重要的阶段，这其中包含了大量为了
  检索数据列到存储引擎的调用以及调用后的数据处理，包括排序、分组等。在完成这些任务的时候，查询需要在不同的地方
  花费时间，包括网络、cpu计算、生成统计信息和执行计划、锁等待等。尤其是向底层存储引擎检索数据的调用操作。这些调用需要在内存操
    
                                
    • 
                                
  • windows系统配置
                                    cherishLC
windows
                                    
    删除Hiberfil.sys ：使用命令powercfg -h off 关闭休眠功能即可： 
http://jingyan.baidu.com/article/f3ad7d0fc0992e09c2345b51.html 
类似的还有pagefile.sys 
 
msconfig 配置启动项 
shutdown 定时关机 
 
ipconfig 查看网络配置 
ipconfig /flushdns
    
                                
    • 
                                
  • 人体的排毒时间
                                    Array_06
工作
                                    
    ======================== 
||  人体的排毒时间是什么时候？|| 
========================  
 
转载于： 
http://zhidao.baidu.com/link?url=ibaGlicVslAQhVdWWVevU4TMjhiKaNBWCpZ1NS6igCQ78EkNJZFsEjCjl3T5EdXU9SaPg04bh8MbY1bR
    
                                
    • 
                                
  • ZooKeeper
                                    cugfy
zookeeper
                                    
    Zookeeper是一个高性能，分布式的，开源分布式应用协调服务。它提供了简单原始的功能，分布式应用可以基于它实现更高级的服务，比如同步， 配置管理，集群管理，名空间。它被设计为易于编程，使用文件系统目录树作为数据模型。服务端跑在java上，提供java和C的客户端API。 Zookeeper是Google的Chubby一个开源的实现，是高有效和可靠的协同工作系统，Zookeeper能够用来lea
    
                                
    • 
                                
  • 网络爬虫的乱码处理
                                    随意而生
爬虫网络
                                    
    下边简单总结下关于网络爬虫的乱码处理。注意，这里不仅是中文乱码，还包括一些如日文、韩文 、俄文、藏文之类的乱码处理，因为他们的解决方式 是一致的，故在此统一说明。     网络爬虫，有两种选择，一是选择nutch、hetriex，二是自写爬虫，两者在处理乱码时，原理是一致的，但前者处理乱码时，要看懂源码后进行修改才可以，所以要废劲一些；而后者更自由方便，可以在编码处理
    
                                
    • 
                                
  • Xcode常用快捷键
                                    张亚雄
xcode
                                    
    一、总结的常用命令： 
 
    隐藏xcode command+h 
 
    退出xcode command+q 
 
    关闭窗口 command+w 
 
    关闭所有窗口 command+option+w 
 
    关闭当前
    
                                
    • 
                                
  • mongoDB索引操作
                                    adminjun
mongodb索引
                                    
    一、索引基础：    MongoDB的索引几乎与传统的关系型数据库一模一样，这其中也包括一些基本的优化技巧。下面是创建索引的命令：    > db.test.ensureIndex({"username":1})    可以通过下面的名称查看索引是否已经成功建立： &nbs
    
                                
    • 
                                
  • 成都软件园实习那些话
                                    aijuans
成都 软件园 实习
                                    
    无聊之中，翻了一下日志，发现上一篇经历是很久以前的事了，悔过~~ 
　　断断续续离开了学校快一年了，习惯了那里一天天的幼稚、成长的环境，到这里有点与世隔绝的感觉。不过还好，那是刚到这里时的想法，现在感觉在这挺好，不管怎么样，最要感谢的还是老师能给这么好的一次催化成长的机会，在这里确实看到了好多好多能想到或想不到的东西。 
　　都说在外面和学校相比最明显的差距就是与人相处比较困难，因为在外面每个人都
    
                                
    • 
                                
  • Linux下FTP服务器安装及配置
                                    ayaoxinchao
linuxFTP服务器vsftp
                                    
    检测是否安装了FTP 
[root@localhost ~]# rpm -q vsftpd 
如果未安装：package vsftpd is not installed  安装了则显示：vsftpd-2.0.5-28.el5累死的版本信息 
  
安装FTP 
运行yum install vsftpd命令，如[root@localhost ~]# yum install vsf
    
                                
    • 
                                
  • 使用mongo-java-driver获取文档id和查找文档
                                    BigBird2012
driver
                                    
    注：本文所有代码都使用的mongo-java-driver实现。 
  
在MongoDB中，一个集合（collection）在概念上就类似我们SQL数据库中的表（Table），这个集合包含了一系列文档（document）。一个DBObject对象表示我们想添加到集合（collection）中的一个文档（document），MongoDB会自动为我们创建的每个文档添加一个id，这个id在
    
                                
    • 
                                
  • JSONObject以及json串
                                    bijian1013
jsonJSONObject
                                    
    一.JAR包简介 
    要使程序可以运行必须引入JSON-lib包，JSON-lib包同时依赖于以下的JAR包： 
    1.commons-lang-2.0.jar 
    2.commons-beanutils-1.7.0.jar 
    3.commons-collections-3.1.jar 
&n
    
                                
    • 
                                
  • [Zookeeper学习笔记之三]Zookeeper实例创建和会话建立的异步特性
                                    bit1129
zookeeper
                                    
    为了说明问题，看个简单的代码， 
  
    import org.apache.zookeeper.*;  
      
    import java.io.IOException;  
    import java.util.concurrent.CountDownLatch;  
    import java.util.concurrent.ThreadLocal
    
                                
    • 
                                
  • 【Scala十二】Scala核心六：Trait
                                    bit1129
scala
                                    
    Traits are a fundamental unit of code reuse in Scala. A trait encapsulates method and field definitions, which can then be reused by mixing them into classes. Unlike class inheritance, in which each c
    
                                
    • 
                                
  • weblogic version 10.3破解
                                    ronin47
weblogic
                                    
    版本：WebLogic Server 10.3 
 
说明：%DOMAIN_HOME%：指WebLogic Server 域(Domain）目录 
例如我的做测试的域的根目录 DOMAIN_HOME=D:/Weblogic/Middleware/user_projects/domains/base_domain 
 
1.为了保证操作安全，备份%DOMAIN_HOME%/security/Defa
    
                                
    • 
                                
  • 求第n个斐波那契数
                                    BrokenDreams

                                    
            今天看到群友发的一个问题：写一个小程序打印第n个斐波那契数。 
        自己试了下，搞了好久。。。基础要加强了。 
        
  &nbs
    
                                
    • 
                                
  • 读《研磨设计模式》-代码笔记-访问者模式-Visitor
                                    bylijinnan
java设计模式
                                    
    声明： 本文只为方便我个人查阅和理解，详细的分析以及源代码请移步 原作者的博客http://chjavach.iteye.com/ 
 
 


import java.util.ArrayList;
import java.util.List;

interface IVisitor {
	
	//第二次分派，Visitor调用Element
	void visitConcret
    
                                
    • 
                                
  • MatConvNet的excise 3改为网络配置文件形式
                                    cherishLC
matlab
                                    
    MatConvNet为vlFeat作者写的matlab下的卷积神经网络工具包，可以使用GPU。 
主页：
http://www.vlfeat.org/matconvnet/ 
教程：
http://www.robots.ox.ac.uk/~vgg/practicals/cnn/index.html 
 
注意：需要下载新版的MatConvNet替换掉教程中工具包中的matconvnet：
http
    
                                
    • 
                                
  • ZK Timeout再讨论
                                    chenchao051
zookeepertimeouthbase
                                    
    http://crazyjvm.iteye.com/blog/1693757 文中提到相关超时问题，但是又出现了一个问题，我把min和max都设置成了180000，但是仍然出现了以下的异常信息： 
Client session timed out, have not heard from server in 154339ms for sessionid 0x13a3f7732340003
    
                                
    • 
                                
  • CASE WHEN 用法介绍
                                    daizj
sqlgroup bycase when
                                    
    CASE WHEN 用法介绍 
 
1. CASE WHEN 表达式有两种形式 
 
 
--简单Case函数  
 
CASE sex  
WHEN '1' THEN '男'  
WHEN '2' THEN '女'  
ELSE '其他' END  
 
--Case搜索函数  
 
CASE 
WHEN sex = '1' THEN 
    
                                
    • 
                                
  • PHP技巧汇总:提高PHP性能的53个技巧
                                    dcj3sjt126com
PHP
                                    
    PHP技巧汇总:提高PHP性能的53个技巧　　用单引号代替双引号来包含字符串，这样做会更快一些。因为PHP会在双引号包围的字符串中搜寻变量，　　单引号则不会，注意：只有echo能这么做，它是一种可以把多个字符串当作参数的函数译注：　　PHP手册中说echo是语言结构，不是真正的函数，故把函数加上了双引号)。　　1、如果能将类的方法定义成static，就尽量定义成static，它的速度会提升将近4倍
    
                                
    • 
                                
  • Yii框架中CGridView的使用方法以及详细示例
                                    dcj3sjt126com
yii
                                    
    CGridView显示一个数据项的列表中的一个表。 
表中的每一行代表一个数据项的数据,和一个列通常代表一个属性的物品(一些列可能对应于复杂的表达式的属性或静态文本)。　　CGridView既支持排序和分页的数据项。排序和分页可以在AJAX模式或正常的页面请求。使用CGridView的一个好处是,当用户浏览器禁用JavaScript,排序和分页自动退化普通页面请求和仍然正常运行。 
实例代码如下：
    
                                
    • 
                                
  • Maven项目打包成可执行Jar文件
                                    dyy_gusi
assembly
                                    
    Maven项目打包成可执行Jar文件 
在使用Maven完成项目以后，如果是需要打包成可执行的Jar文件，我们通过eclipse的导出很麻烦，还得指定入口文件的位置，还得说明依赖的jar包，既然都使用Maven了，很重要的一个目的就是让这些繁琐的操作简单。我们可以通过插件完成这项工作，使用assembly插件。具体使用方式如下： 
1、在项目中加入插件的依赖： 
<plugin>
	
    
                                
    • 
                                
  • php常见错误
                                    geeksun
PHP
                                    
    1.  kevent() reported that connect() failed (61: Connection refused) while connecting to upstream, client: 127.0.0.1, server: localhost, request: "GET / HTTP/1.1", upstream: "fastc
    
                                
    • 
                                
  • 修改linux的用户名
                                    hongtoushizi
linuxchange password
                                    
    Change Linux Username 
更改Linux用户名，需要修改4个系统的文件： 
/etc/passwd 
/etc/shadow 
/etc/group 
/etc/gshadow 
古老/传统的方法是使用vi去直接修改，但是这有安全隐患（具体可自己搜一下），所以后来改成使用这些命令去代替： 
vipw 
vipw -s 
vigr 
vigr -s 
  
具体的操作顺
    
                                
    • 
                                
  • 第五章 常用Lua开发库1-redis、mysql、http客户端
                                    jinnianshilongnian
nginxlua
                                    
    对于开发来说需要有好的生态开发库来辅助我们快速开发，而Lua中也有大多数我们需要的第三方开发库如Redis、Memcached、Mysql、Http客户端、JSON、模板引擎等。 
一些常见的Lua库可以在github上搜索，https://github.com/search?utf8=%E2%9C%93&q=lua+resty。 
  Redis客户端 
lua-resty-r
    
                                
    • 
                                
  • zkClient 监控机制实现
                                    liyonghui160com
zkClient 监控机制实现
                                    
      
       直接使用zk的api实现业务功能比较繁琐。因为要处理session loss，session expire等异常，在发生这些异常后进行重连。又因为ZK的watcher是一次性的，如果要基于wather实现发布/订阅模式，还要自己包装一下，将一次性订阅包装成持久订阅。另外如果要使用抽象级别更高的功能，比如分布式锁，leader选举
    
                                
    • 
                                
  • 在Mysql 众多表中查找一个表名或者字段名的 SQL 语句
                                    pda158
mysql
                                    
    在Mysql 众多表中查找一个表名或者字段名的 SQL 语句：   
　　方法一：SELECT table_name, column_name from information_schema.columns WHERE column_name LIKE 'Name';
　　方法二：SELECT column_name from information_schema.colum
    
                                
    • 
                                
  • 程序员对英语的依赖
                                    Smile.zeng
英语程序猿
                                    
    1、程序员最基本的技能，至少要能写得出代码，当我们还在为建立类的时候思考用什么单词发牢骚的时候，英语与别人的差距就直接表现出来咯。 
2、程序员最起码能认识开发工具里的英语单词，不然怎么知道使用这些开发工具。 
3、进阶一点，就是能读懂别人的代码，有利于我们学习人家的思路和技术。 
4、写的程序至少能有一定的可读性，至少要人别人能懂吧... 
 
以上一些问题，充分说明了英语对程序猿的重要性。骚年
    
                                
    • 
                                
  • Oracle学习笔记(8) 使用PLSQL编写触发器
                                    vipbooks
oraclesql编程活动Access
                                    
        时间过得真快啊，转眼就到了Oracle学习笔记的最后个章节了，通过前面七章的学习大家应该对Oracle编程有了一定了了解了吧，这东东如果一段时间不用很快就会忘记了，所以我会把自己学习过的东西做好详细的笔记，用到的时候可以随时查找，马上上手！希望这些笔记能对大家有些帮助！ 
    这是第八章的学习笔记，学习完第七章的子程序和包之后
    
                                
    •