benxiaohai888
benxiaohai888

Hibernate OID、导航图、HQL、SQL、QBC查询方式示例

Hibernate OID、导航图、HQL、SQL、QBC查询方法示例

本案例使用的hibernate版本为  hibernate-release-5.2.10.Final 

为了测试，本案例在mysql数据库中创建了一个db数据库。

示例描述一个案例，在网上购物系统中一个用户可以有多个订单，所以用户和订单属于一对多关系，在cn.sz.pojo包下面是他们的实体并用注解进行了映射配置。cn.sz.pojo包下面的User.java和User.hbm.xml用于HQL查询时利用查询名称实现查询时使用。

创建一个java项目：项目的结构如下：（lib文件夹用于存放jar包）

Hibernate OID、导航图、HQL、SQL、QBC查询方式示例_第1张图片

lib目录下则是hibernate5需要的jar包（注需要将jar加载到项目中：选中jar包右键 --》BuildPath--》Add to Build Path）
Hibernate OID、导航图、HQL、SQL、QBC查询方式示例_第2张图片
log4j.properties为日志配置文件（需要加载配置junit），此项目可以不需要日志，使用日志只是为了观察方便。
注：junit配置可以参考 http://blog.csdn.net/benxiaohai888/article/details/78231911

由于在主配置文件配置了字段创建数据表的配置，所以第一次加载时就会自动创建数据表

配置的代码：


update


接下来是示例代码：

1、主配置文件 hibernate.cfg.xml copy




	
		
		
		com.mysql.jdbc.Driver
		
		jdbc:mysql://localhost:3306/db?characterEncoding=utf8
		
		root
		
		

		
		org.hibernate.dialect.MySQL5Dialect

		

		

		
		true
		
		true
		
		update
		
		thread
		
		4



2、工具类（获取Session）HibernateUtil.java

[java] view plain copy
  1. package cn.sz.utils;  
  2.   
  3. import org.hibernate.Session;  
  4. import org.hibernate.SessionFactory;  
  5. import org.hibernate.cfg.Configuration;  
  6.   
  7. public class HibernateUtil {  
  8.     public static Session getSession() {  
  9.         Session session = null;  
  10.         // 创建一个读取主配置文件的对象  
  11.         Configuration cfg = new Configuration();  
  12.         // 读取主配置文件  
  13.         cfg.configure();  
  14.         // 创建Session工厂  
  15.         SessionFactory factory = cfg.buildSessionFactory();  
  16.         // 打开Session  
  17.         // session = factory.openSession();  
  18.         // 如果在主配置文件将session绑定到线程中，所以可以从线程中取出session  
  19.         session = factory.getCurrentSession();  
  20.         return session;  
  21.     }  
  22. }  

3、日志文件 log4j.properties

[plain] view plain copy
  1. log4j.rootLogger=DEBUG,console,FILE  
  2. log4j.appender.console=org.apache.log4j.ConsoleAppender  
  3. log4j.appender.console.threshold=INFO  
  4. log4j.appender.console.layout=org.apache.log4j.PatternLayout  
  5. log4j.appender.console.layout.ConversionPattern=%d{yyyy-MM-dd HH:mm:ss} [%5p] - %c -%F(%L) -%m%n  
  6. log4j.appender.FILE=org.apache.log4j.RollingFileAppender  
  7. log4j.appender.FILE.maxBackupIndex=100  
  8. ##log4j.appender.FILE=org.apache.log4j.DailyRollingFileAppender   
  9. log4j.appender.FILE.Append=true  
  10. log4j.appender.FILE.File=c:/error1.log  
  11. log4j.appender.FILE.Threshold=INFO  
  12. log4j.appender.FILE.layout=org.apache.log4j.PatternLayout  
  13. log4j.appender.FILE.layout.ConversionPattern=%d{yyyy-MM-dd HH:mm:ss} [%5p] - %c -%F(%L) -%m%n  
  14. log4j.appender.FILE.MaxFileSize=1MB  
4、实体类User.java(sn.sz.pojo包下面) 

package cn.sz.pojo;

import java.util.Date;
import java.util.Set;

import javax.persistence.CascadeType;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.OneToMany;
import javax.persistence.Table;

@Entity
@Table(name = "h_user")
public class User {
	// 基于外键的方式时，使用的配置(一对一关系)

	@Id
	@GeneratedValue(strategy = GenerationType.IDENTITY)
	private Integer userId;

	private String userName;
	private Date birthday;

	// 一对多关系(用户和订单),添加cascade配置并不能实现一的一方维护关系
	@OneToMany(targetEntity = Orders.class, mappedBy = "user", cascade = CascadeType.ALL)
	private Set orderss;

	public User() {
	}

	public User(String userName, Date birthday) {
		this.userName = userName;
		this.birthday = birthday;
	}

	public Integer getUserId() {
		return userId;
	}

	public void setUserId(Integer userId) {
		this.userId = userId;
	}

	public String getUserName() {
		return userName;
	}

	public void setUserName(String userName) {
		this.userName = userName;
	}

	public Date getBirthday() {
		return birthday;
	}

	public void setBirthday(Date birthday) {
		this.birthday = birthday;
	}

	public Set getOrderss() {
		return orderss;
	}

	public void setOrderss(Set orderss) {
		this.orderss = orderss;
	}

	@Override
	public String toString() {
		return "User [userId=" + userId + ", userName=" + userName + ", birthday=" + birthday + "]";
	}

}

5、实体类 Orders.java 

package cn.sz.pojo;

import javax.persistence.Basic;
import javax.persistence.CascadeType;
import javax.persistence.Entity;
import javax.persistence.FetchType;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.ManyToOne;
import javax.persistence.Table;

@Entity
@Table(name = "h_orders")
public class Orders {
	@Id
	@GeneratedValue(strategy = GenerationType.IDENTITY)
	private Integer ordersId;
	private String ordersName;

	// 一对多关系(用户和订单)
	@ManyToOne(cascade = CascadeType.ALL)
	@JoinColumn(name = "userId")
	@Basic(fetch = FetchType.LAZY) //// 添加此项配置并不能实现一的一方维护关系
	private User user;

	public Integer getOrdersId() {
		return ordersId;
	}

	public void setOrdersId(Integer ordersId) {
		this.ordersId = ordersId;
	}

	public String getOrdersName() {
		return ordersName;
	}

	public void setOrdersName(String ordersName) {
		this.ordersName = ordersName;
	}

	public User getUser() {
		return user;
	}

	public void setUser(User user) {
		this.user = user;
	}

	@Override
	public String toString() {
		return "Orders [ordersId=" + ordersId + ", ordersName=" + ordersName + "]";
	}

}

6、实体类User.java(sn.sz.vo下面) 


package cn.sz.vo;

import java.util.Date;

public class User {
	private Integer userId;
	private String userName;
	private Date birthday;

	public Integer getUserId() {
		return userId;
	}

	public void setUserId(Integer userId) {
		this.userId = userId;
	}

	public String getUserName() {
		return userName;
	}

	public void setUserName(String userName) {
		this.userName = userName;
	}

	public Date getBirthday() {
		return birthday;
	}

	public void setBirthday(Date birthday) {
		this.birthday = birthday;
	}

}
7、映射文件 User.hbm.xml

测试类：

OID查询、导航图查询、HQL、测试类：

package cn.sz.test;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Arrays;
import java.util.Date;
import java.util.List;
import java.util.Set;

import org.hibernate.Session;
import org.hibernate.query.Query;
import org.junit.Test;

import com.mysql.fabric.xmlrpc.base.Array;

import cn.sz.pojo.Orders;
import cn.sz.pojo.User;
import cn.sz.utils.HibernateUtil;

public class QueryTest {

	@Test
	// 添加测试数据
	public void testSave() {
		Session session = HibernateUtil.getSession();
		session.beginTransaction();
		// 创建一个用户
		User u = new User();
		u.setUserName("张三");
		u.setBirthday(new Date());

		Orders orders1 = new Orders();
		orders1.setOrdersName("衣服");
		orders1.setUser(u);

		Orders orders2 = new Orders();
		orders2.setOrdersName("武器");
		orders2.setUser(u);

		// 继续创建一个用户
		User u2 = new User();
		u2.setUserName("李四");
		u2.setBirthday(new Date());

		Orders orders3 = new Orders();
		orders3.setOrdersName("水果");
		orders3.setUser(u2);

		Orders orders4 = new Orders();
		orders4.setOrdersName("鞋子");
		orders4.setUser(u2);

		// 继续创建一个用户
		User u3 = new User();
		u3.setUserName("王五");
		u3.setBirthday(new Date());

		Orders orders5 = new Orders();
		orders5.setOrdersName("水果");
		orders5.setUser(u3);

		session.save(orders1);
		session.save(orders2);
		session.save(orders3);
		session.save(orders4);
		session.save(orders5);
		session.save(u);
		session.save(u2);
		session.save(u3);
		session.getTransaction().commit();
		session.close();
	}

	@Test
	// OID查询方式 get()方法和load() 方法
	public void testOIDQuery() {
		Session session = HibernateUtil.getSession();
		session.beginTransaction();

		User u1 = session.get(User.class, 1);
		System.out.println(u1.toString());

		User u2 = session.load(User.class, 1);
		System.out.println(u2.toString());

		Set orderss = u2.getOrderss();// 导航图查询方式
		for (Orders orders : orderss) {
			System.out.println(orders.toString());
		}

		session.getTransaction().commit();
		session.close();
	}

	@Test
	// HQL查询方式
	public void testHQlQuery1() {
		Session session = HibernateUtil.getSession();
		session.beginTransaction();
		// HQL 查询user表的所有记录
		String hql = "FROM User u";
		Query query = session.createQuery(hql);
		List list = query.list();
		for (Object o : list) {
			System.out.println(o.toString());
		}

		session.getTransaction().commit();
		session.close();
	}

	@Test
	// HQL查询方式
	public void testHQlQuery2() {
		Session session = HibernateUtil.getSession();
		session.beginTransaction();
		// HQL 查询user表的编号大于1的记录
		String hql = "FROM User u WHERE u.userId > 1";
		Query query = session.createQuery(hql);
		List list = query.list();
		for (Object o : list) {
			System.out.println(o.toString());
		}

		session.getTransaction().commit();
		session.close();
	}

	@Test
	// HQL查询方式
	public void testHQlQuery3() {
		Session session = HibernateUtil.getSession();
		session.beginTransaction();
		String c = "李";
		// HQL 查询user表的姓名中有李记录
		String hql = "FROM User u WHERE u.userName like '%" + c + "%'";
		Query query = session.createQuery(hql);
		List list = query.list();
		for (Object o : list) {
			System.out.println(o.toString());
		}

		session.getTransaction().commit();
		session.close();
	}

	@Test
	// HQL查询方式
	public void testHQlQuery4() {
		Session session = HibernateUtil.getSession();
		session.beginTransaction();
		String c = "李";
		// HQL 查询user表的id为1的记录（只有一个）
		String hql = "FROM User u WHERE u.userId=1";
		Query query = session.createQuery(hql);
		Object result = query.uniqueResult();
		System.out.println(result);
		session.getTransaction().commit();
		session.close();
	}

	@Test
	// HQL查询方式
	public void testHQlQuery5() {
		Session session = HibernateUtil.getSession();
		session.beginTransaction();

		// HQL 查询user表的id为1在1-2范围，姓名为李四的记录
		String hql = "FROM User u WHERE u.userId in(1,2) AND u.userName='李四'";
		Query query = session.createQuery(hql);
		List list = query.list();
		for (Object o : list) {
			System.out.println(o.toString());
		}
		session.getTransaction().commit();
		session.close();
	}

	@Test
	// HQL查询方式
	public void testHQlQuery6() {
		Session session = HibernateUtil.getSession();
		session.beginTransaction();

		// HQL 查询user表的所有记录，按姓名降序排序
		String hql = "FROM User u ORDER BY u.userName DESC";
		Query query = session.createQuery(hql);
		List list = query.list();
		for (Object o : list) {
			System.out.println(o.toString());
		}
		session.getTransaction().commit();
		session.close();
	}

	@Test
	// HQL查询方式
	public void testHQlQuery7() {
		Session session = HibernateUtil.getSession();
		session.beginTransaction();

		// HQL 统计user表的记录总数
		String hql = "SELECT COUNT(*) FROM User u";
		Query query = session.createQuery(hql);
		Object result = query.uniqueResult();
		System.out.println(result.toString());

		session.getTransaction().commit();
		session.close();
	}

	@Test
	// HQL查询方式
	public void testHQlQuery8() {
		Session session = HibernateUtil.getSession();
		session.beginTransaction();

		// HQL查询不同用户的订单数目
		String hql = "SELECT COUNT(*) FROM Orders o GROUP BY o.user";
		Query query = session.createQuery(hql);
		List list = query.list();
		for (Object o : list) {
			System.out.println(o.toString());
		}

		session.getTransaction().commit();
		session.close();
	}

	@Test
	// HQL查询方式
	public void testHQlQuery9() {
		Session session = HibernateUtil.getSession();
		session.beginTransaction();

		// HQL查询--查询user的姓名
		String hql = "SELECT u.userName FROM User u";
		Query query = session.createQuery(hql);
		List list = query.list();
		for (Object o : list) {
			System.out.println(o.toString());
		}

		session.getTransaction().commit();
		session.close();
	}

	@Test
	// HQL查询方式
	public void testHQlQuery10() {
		Session session = HibernateUtil.getSession();
		session.beginTransaction();

		// HQL查询--查询user的姓名和生日
		String hql = "SELECT u.userName,u.birthday FROM User u";
		Query query = session.createQuery(hql);
		List list = query.list();
		for (Object o : list) {
			if (o.getClass().isArray())
				System.out.println(Arrays.toString((Object[]) o));
			else
				System.out.println(o);

		}
		session.getTransaction().commit();
		session.close();
	}

	@Test
	// HQL查询方式
	public void testHQlQuery11() {
		Session session = HibernateUtil.getSession();
		session.beginTransaction();

		// HQL查询--查询user的姓名和生日
		String hql = "SELECT new User(u.userName,u.birthday) FROM User u";
		Query query = session.createQuery(hql);
		List list = query.list();
		for (Object o : list) {

			System.out.println(o);

		}
		session.getTransaction().commit();
		session.close();
	}

	@Test
	// HQL查询方式
	public void testHQlQuery12() {
		Session session = HibernateUtil.getSession();
		session.beginTransaction();

		// HQL查询--查询user的姓名和生日,实现分页
		String hql = "SELECT new User(u.userName,u.birthday) FROM User u";
		Query query = session.createQuery(hql);
		// 设置分页
		query.setFirstResult(0);
		query.setMaxResults(2);

		List list = query.list();
		for (Object o : list) {

			System.out.println(o);

		}
		session.getTransaction().commit();
		session.close();
	}

	@Test
	// HQL查询方式
	public void testHQlQuery13() {
		Session session = HibernateUtil.getSession();
		session.beginTransaction();

		// HQL查询--设置查询条件，采用占位符的方案(占位符从0开始)
		String hql = "SELECT u.userName,u.birthday FROM User u WHERE u.userName=?";
		Query query = session.createQuery(hql);
		query.setParameter(0, "李四");

		List list = query.list();
		for (Object o : list) {
			if (o.getClass().isArray())
				System.out.println(Arrays.toString((Object[]) o));
			else
				System.out.println(o);

		}
		session.getTransaction().commit();
		session.close();
	}

	@Test
	// HQL查询方式
	public void testHQlQuery14() {
		Session session = HibernateUtil.getSession();
		session.beginTransaction();

		// HQL查询--设置查询条件，采用占位符的方案(占位符从0开始)
		String hql = "SELECT u.userName,u.birthday FROM User u WHERE u.userName like ?";
		Query query = session.createQuery(hql);
		// query.setParameter(0, "%李%");
		String c = "李";
		query.setParameter(0, "%" + c + "%");

		List list = query.list();
		for (Object o : list) {
			if (o.getClass().isArray())
				System.out.println(Arrays.toString((Object[]) o));
			else
				System.out.println(o);

		}
		session.getTransaction().commit();
		session.close();
	}

	@Test
	// HQL查询方式
	public void testHQlQuery15() {
		Session session = HibernateUtil.getSession();
		session.beginTransaction();

		// HQL查询--设置查询条件，采用占位符的方案(占位符从0开始)
		String hql = "SELECT u.userName,u.birthday FROM User u WHERE u.userId IN(?,?)";
		Query query = session.createQuery(hql);
		query.setParameter(0, 1);
		query.setParameter(1, 2);

		List list = query.list();
		for (Object o : list) {
			if (o.getClass().isArray())
				System.out.println(Arrays.toString((Object[]) o));
			else
				System.out.println(o);

		}
		session.getTransaction().commit();
		session.close();
	}

	@Test
	// HQL查询方式
	public void testHQlQuery16() {
		Session session = HibernateUtil.getSession();
		session.beginTransaction();

		// HQL查询--设置查询条件，采用查询变量方案
		String hql = "SELECT u.userName,u.birthday FROM User u WHERE u.userName=:name";
		Query query = session.createQuery(hql);
		query.setParameter("name", "王五");

		List list = query.list();
		for (Object o : list) {
			if (o.getClass().isArray())
				System.out.println(Arrays.toString((Object[]) o));
			else
				System.out.println(o);

		}
		session.getTransaction().commit();
		session.close();
	}

	@Test
	// HQL查询方式
	public void testHQlQuery17() {
		Session session = HibernateUtil.getSession();
		session.beginTransaction();

		// HQL查询--设置查询条件，采用查询变量方案
		String hql = "SELECT u.userName,u.birthday FROM User u WHERE u.userId BETWEEN :start AND :end";
		Query query = session.createQuery(hql);
		query.setParameter("start", 1);
		query.setParameter("end", 3);

		List list = query.list();
		for (Object o : list) {
			if (o.getClass().isArray())
				System.out.println(Arrays.toString((Object[]) o));
			else
				System.out.println(o);

		}
		session.getTransaction().commit();
		session.close();
	}

	@Test
	// HQL查询方式
	public void testHQlQuery18() {
		Session session = HibernateUtil.getSession();
		session.beginTransaction();

		// HQL查询--设置查询条件，采用查询变量方案
		String hql = "SELECT u.userName,u.birthday FROM User u WHERE u.userId BETWEEN :start AND :end";
		Query query = session.createQuery(hql);
		query.setParameter("start", 1);
		query.setParameter("end", 3);

		List list = query.list();
		for (Object o : list) {
			if (o.getClass().isArray())
				System.out.println(Arrays.toString((Object[]) o));
			else
				System.out.println(o);

		}
		session.getTransaction().commit();
		session.close();
	}

	@Test
	// HQL查询方式
	public void testHQlQuery19() throws ParseException {
		Session session = HibernateUtil.getSession();
		session.beginTransaction();

		// HQL查询--设置查询条件，采用查询变量方案
		String hql = "SELECT u.userName,u.birthday FROM User u WHERE u.birthday BETWEEN :start AND :end";
		Query query = session.createQuery(hql);

		SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
		Date d1 = sdf.parse("2017-10-23 0:0:0");
		Date d2 = sdf.parse("2017-10-25 0:0:0");
		query.setParameter("start", d1);
		query.setParameter("end", d2);

		List list = query.list();
		for (Object o : list) {
			if (o.getClass().isArray())
				System.out.println(Arrays.toString((Object[]) o));
			else
				System.out.println(o);

		}
		session.getTransaction().commit();
		session.close();
	}

	@Test
	// HQL查询方式
	public void testHQlQuery20() throws ParseException {
		Session session = HibernateUtil.getSession();
		session.beginTransaction();

		// HQL查询--设置查询条件，采用查询变量方案
		/*
		 * 在HQL中，占位符的个数不能确定，换句话说假设从页面传入的同一个条件值， 在不同请求时所传值的个数不同，导致占位符的个数不能确定
		 */
		String hql = "SELECT u.userName,u.birthday FROM User u WHERE u.userId in(:ids)";
		Query query = session.createQuery(hql);

		query.setParameterList("ids", new Object[] { 1, 2 });

		List list = query.list();
		for (Object o : list) {
			if (o.getClass().isArray())
				System.out.println(Arrays.toString((Object[]) o));
			else
				System.out.println(o);

		}
		session.getTransaction().commit();
		session.close();
	}

	@Test
	// HQL查询方式(连接查询)
	public void testHQlQuery21() throws ParseException {
		Session session = HibernateUtil.getSession();
		session.beginTransaction();

		// HQL查询--连接查询
		String hql = "SELECT u.userName,u.birthday FROM User u,Orders o WHERE u.userId =o.user";
		Query query = session.createQuery(hql);

		List list = query.list();
		for (Object o : list) {
			if (o.getClass().isArray())
				System.out.println(Arrays.toString((Object[]) o));
			else
				System.out.println(o);

		}
		session.getTransaction().commit();
		session.close();
	}

	@Test
	// HQL查询方式
	public void testHQlQuery22() throws ParseException {
		Session session = HibernateUtil.getSession();
		session.beginTransaction();

		// HQL查询--连接查询
		// String hql = "SELECT u.userName,u.birthday,o.ordersId,o.ordersName
		// FROM User u JOIN Orders o
		// ON u.userId =o.user";
		// String hql = "SELECT u.userName,u.birthday,o.ordersId,o.ordersName
		// FROM Orders o JOIN o.user
		// u";
		String hql = "SELECT o.user.userName,o.user.birthday,o.ordersId,o.ordersName FROM Orders o";
		Query query = session.createQuery(hql);

		List list = query.list();
		for (Object o : list) {
			if (o.getClass().isArray())
				System.out.println(Arrays.toString((Object[]) o));
			else
				System.out.println(o);

		}
		session.getTransaction().commit();
		session.close();
	}

	@Test
	// HQL查询方式
	public void testHQlQuery23() throws ParseException {
		Session session = HibernateUtil.getSession();
		session.beginTransaction();

		// 连接查询---内连接查询，迫切内连接查询，fetch作用是实现迫切连接查询
		// 迫切查询和非迫切查询区别是非迫切的查询结果是数组形式，迫切查询结果是对象形式
		// String hql = "SELECT u.userId,u.userName,o.ordersId,o.ordersName FROM
		// User u INNER JOIN FETCH Orders o ON u.userId=o.user";
		String hql = "select u.userId,u.username,o.ordersId,o.ordersName from Orders o join fetch o.user u";
		Query query = session.createQuery(hql);

		List list = query.list();
		for (Object o : list) {
			if (o.getClass().isArray())
				System.out.println(Arrays.toString((Object[]) o));
			else
				System.out.println(o);

		}
		session.getTransaction().commit();
		session.close();
	}

	@Test
	// HQL查询方式
	public void testHQlQuery24() throws ParseException {
		Session session = HibernateUtil.getSession();
		session.beginTransaction();

		// 连接查询---内连接查询，迫切内连接查询，fetch作用是实现迫切连接查询
		// 迫切查询和非迫切查询区别是非迫切的查询结果是数组形式，迫切查询结果是对象形式
		// 迫切查询只有迫切内连接查询和迫切左外连接查询
		// String hql = "SELECT u.userId,u.userName,o.ordersId,o.ordersName FROM
		// User u left fetch Orders o ON u.userId=o.user";
		String hql = "SELECT u.userId,u.username,o.ordersId,o.ordersName FROM User u right join Orders o on u.userId=o.user";
		Query query = session.createQuery(hql);

		List list = query.list();
		for (Object o : list) {
			if (o.getClass().isArray())
				System.out.println(Arrays.toString((Object[]) o));
			else
				System.out.println(o);

		}
		session.getTransaction().commit();
		session.close();
	}

	@Test
	public void test25() {
		Session session = HibernateUtil.getSession();
		session.beginTransaction();
		// 利用查询名称实现查询
		Query query = session.createNamedQuery("queryUser");
		List list = query.list();
		for (Object o : list) {
			if (o.getClass().isArray())
				System.out.println(Arrays.toString((Object[]) o));
			else
				System.out.println(o);

		}
		session.getTransaction().commit();
		session.close();

	}

	@Test
	public void test26() {
		Session session = HibernateUtil.getSession();
		session.beginTransaction();
		// 利用查询名称实现查询
		Query query = session.createNamedQuery("queryUser2");
		List list = query.list();
		for (Object o : list) {
			if (o.getClass().isArray())
				System.out.println(Arrays.toString((Object[]) o));
			else
				System.out.println(o);

		}
		session.getTransaction().commit();
		session.close();

	}

}


QBC查询测试类：

package cn.sz.test;

import java.util.Arrays;
import java.util.List;

import org.hibernate.Criteria;
import org.hibernate.Session;
import org.hibernate.criterion.DetachedCriteria;
import org.hibernate.criterion.Restrictions;
import org.junit.Test;

import cn.sz.pojo.User;
import cn.sz.utils.HibernateUtil;

public class CriteriaTest {
	@Test
	public void test1() {
		Session session = HibernateUtil.getSession();
		session.beginTransaction();
		// 认识QBC查询
		Criteria criteria = session.createCriteria(User.class);
		List list = criteria.list();
		for (Object object : list) {
			System.out.println(object);
		}

		session.getTransaction().commit();
		session.close();
	}

	@Test
	public void test2() {
		Session session = HibernateUtil.getSession();
		session.beginTransaction();
		// 认识QBC查询--查询一个结果
		Criteria criteria = session.createCriteria(User.class);

		criteria.add(Restrictions.eqOrIsNull("userId", 1));
		Object o = criteria.uniqueResult();
		System.out.println(o);
		session.getTransaction().commit();
		session.close();
	}

	@Test
	public void test3() {
		Session session = HibernateUtil.getSession();
		session.beginTransaction();
		// 认识QBC查询--查询一个结果
		Criteria criteria = session.createCriteria(User.class);
		// 分页操作
		criteria.setFirstResult(0);
		criteria.setMaxResults(2);

		List list = criteria.list();
		for (Object object : list) {
			if (object.getClass().isArray())
				System.out.println(Arrays.toString((Object[]) object));
			else
				System.out.println(object);
		}
		session.getTransaction().commit();
		session.close();
	}

	@Test
	public void test4() {
		Session session = HibernateUtil.getSession();
		session.beginTransaction();
		// 离线查询--创建一个离线查询对象
		DetachedCriteria dCriteria = DetachedCriteria.forClass(User.class);
		Criteria criteria = dCriteria.getExecutableCriteria(session);
		criteria.add(Restrictions.in("userId", 1, 2, 3));
		List list = criteria.list();

		for (Object object : list) {
			if (object.getClass().isArray())
				System.out.println(Arrays.toString((Object[]) object));
			else
				System.out.println(object);
		}
		session.getTransaction().commit();
		session.close();
	}
}

SQL查询测试类： 

package cn.sz.test;

import java.util.Arrays;
import java.util.List;

import org.hibernate.SQLQuery;
import org.hibernate.Session;
import org.hibernate.query.NativeQuery;
import org.junit.Test;

import cn.sz.utils.HibernateUtil;

public class SQLTest {
	@Test
	@SuppressWarnings("rawtypes") // 去除警告提示
	public void test1() {
		Session session = HibernateUtil.getSession();
		session.beginTransaction();

		// 查询所有的用户
		String sql = "select * from h_user";
		SQLQuery query = session.createSQLQuery(sql);

		List list = query.list();

		for (Object o : list) {
			// 如果是数组则转换为字符串打印输出
			if (o.getClass().isArray())
				System.out.println(Arrays.toString((Object[]) o));
			else
				// 否则调用对象的toString() 方法打印输出
				System.out.println(o);
		}
		session.getTransaction().commit();
		session.close();
	}

	@Test
	@SuppressWarnings("rawtypes")
	public void test2() {
		Session session = HibernateUtil.getSession();
		session.beginTransaction();

		// 查询id为1的用户
		String sql = "select * from h_user where userid=1";
		SQLQuery sqlQuery = session.createSQLQuery(sql);
		// 结果为唯一值
		Object o = sqlQuery.uniqueResult();
		if (o.getClass().isArray())
			System.out.println(Arrays.toString((Object[]) o));
		else
			System.out.println(o);
		session.getTransaction().commit();
		session.close();
	}

	@Test
	@SuppressWarnings("rawtypes")
	public void test3() {
		Session session = HibernateUtil.getSession();
		session.beginTransaction();
		// 分页查询
		String sql = "select * from h_user";
		SQLQuery sqlQuery = session.createSQLQuery(sql);
		// 设置查询起始位置
		sqlQuery.setFirstResult(0);
		// 设置查询记录数
		sqlQuery.setMaxResults(3);

		List list = sqlQuery.list();

		for (Object o : list) {
			if (o.getClass().isArray())
				System.out.println(Arrays.toString((Object[]) o));
			else
				System.out.println(o);
		}

		session.getTransaction().commit();
		session.close();
	}
}
 
  
 注：我们在利用查询名称实现查询的时候需要使用cn.sz.vo下面的User实体类和User.hbmxml映射文件,还需要注释主配置中的下面代码， 
  
 
   
 
  
 并打开
 
  
 
 
  
 
  

 
  

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(Hibernate)

        

            

                
    
                    
  • spring整合hibernate最基础的方式
                        木木ainiks
hibernatespringjava
                        
    1创建文件，可以创建web文件目录2导入jar包，需要导全，我就是jar没导全，后面怎么运行都不对3配置applicationContext.xml<beanid="sessionFactory"
    
                    
    • 
                    
  • Spring Data JPA
                        kjcoder
SpringDataJPA后端
                        
    JPA概述JPA的全称是JavaPersistenceAPI，即Java持久化API，是SUN公司推出的一套基于ORM的规范，内部是由一系列的接口和抽象类构成。JPA规范不干活，真正干活的是依托与它的实现方式(例：hibernate)。搭建环境（需求：保存客户）1.创建maven工程导入坐标org.hibernatehibernate-entitymanager2.需要配置jpa的核心配置文件*位
    
                    
    • 
                    
  • 搭建第一个SpringDataJPA工程
                        码来码去（未来可期）
JavaWebjava
                        
    第一步：创建maven工程，导入maven坐标使用SpringDataJPA，需要整合Spring与SpringDataJPA，并且需要提供JPA的服务提供者hibernate，所以需要导入spring相关坐标，hibernate坐标，数据库驱动坐标等4.2.4.RELEASE5.0.7.Final1.6.61.2.120.9.1.25.1.6junitjunit4.9testorg.aspect
    
                    
    • 
                    
  • 讨论视频系统架构
                        Robin-LV
MVCJDBC
                        
    今天接到一个业务，领导让我搭建一个视频系统架构。架构采用MVC的模式这个大家都知道，技术采用Sping，hibernate3，数据层采用Sping提供的的jdbc模板。我知道要提供一些公共的的类和接口。还有一些封装好的方法。这个架构要考虑现在老系统的数据，等新系统完成要把数据导过去，还要考虑多平台融合的问题。由于我们公司有多套系统，领导想做底层统一以后好管理。现在晕晕的，请高手谈谈如何搭建一个好的
    
                    
    • 
                    
  • log4jdbc使用介绍
                        leechiwi
log4jdbc
                        
    0前言使用java进行数据库操作时最痛苦的莫过于拼接SQL语句。在实际运行时往往需要查看实际生成的SQL语句和实际传入的参数，或许还会有查看SQL执行时间等的需求。无论原生JDBC、dbutils、mybatis还是hibernate，使用log4j等日志框架可以看到生成的SQL，但是占位符和参数总是分开打印的。实在是不太友好。显示如下的效果:select*fromt_userwhereage>?
    
                    
    • 
                    
  • 短视频矩阵源码
                        fendou--yx898978
抖音账号矩阵系统源码开发python开发语言矩阵
                        
    矩阵系统源码主要有三种框架：Spring、Struts和Hibernate。Spring框架是一个全栈式的Java应用程序开发框架，提供了IOC容器、AOP、事务管理等功能。Struts框架是一个MVC架构的Web应用程序框架，用于将数据模型、Web应用程序的用户界面和控制器逻辑分离。Hibernate框架是一个面向对象的数据库访问框架，提供了ORM（对象关系映射）机制，允许开发人员使用面向对象的
    
                    
    • 
                    
  • Java项目中参数校验方法
                        DebugDiver代码深处潜水员
项目相关javapython开发语言
                        
    Java项目中参数校验方法1.参数校验的重要性2.常见的参数校验方法2.1使用`assert`关键字2.2使用`Objects.requireNonNull`2.3使用自定义异常2.4使用`Preconditions`类2.5使用HibernateValidator注解2.6使用Spring框架内的验证2.7使用JSR303/349（BeanValidation）2.8使用ApacheCommon
    
                    
    • 
                    
  • Java架构师学习路线
                        网络全息测量
心得体会
                        
    (1)第一步：研究spring,hibernate。通过研究jeecms开源框架。也同时学习css,html,javascript,jquery.以前都学习过，不过没有系统学习过，现在必须系统学习。同时看cms相关的论文。然后，改造jeecms能够改为自己的一个开源框架，以后开发cms系统都用我自己开发的框架，作为第一阶段的成果。(2)第二步：学习开源工作流引擎Activiti5，jbpm4.4以
    
                    
    • 
                    
  • SpringBoot操作GBase8s数据库示例
                        迷你世界～爱丽丝

                        
    SpringBoot+Hibernate(Jpa)操作GBase8s数据库示例GBase8s数据库是国产事务型数据库，目前已在各领域广泛应用，本篇使用当下主流的J2EE框架Springboot集成Hibernate（Jpa），对GBasse8S数据库CRUD操作进行讲解。1.技术点JPA是JAVA标准持久化API，是SUN公司推出的一套基于ORM的规范；Hibernate是对JPA（ORM规范）的
    
                    
    • 
                    
  • chapter01 Java语言概述 知识点Note
                        月下绯烟
Javajava开发语言
                        
    JavaSEJavaEEJavaME大数据Java基础常用技术栈mysqlJDBCSSMspring+springmvc+mybatisLinuxnacosHadoopFlinkJAVAEE消息队列rabbitMQdocker数据库redisspringbootspringcloudsshstruts+spring+hibernate过时技术栈很少用JAVA虚拟机jvm分布式微服务高并发常见dos
    
                    
    • 
                    
  • SpringBoot学习（5）Spring boot Jpa使用
                        星河漫漫l
springboot开发语言运维开发学习
                        
    SpringBootJpa介绍首先了解Jpa是什么？Jpa(JavaPersistenceAPI)是Sun官方提出的Java持久化规范。它为Java开发人员提供了一种对象/关联映射工具来管理Java应用中的关系数据。它的出现主要是为了简化现有的持久化开发工作和整合ORM技术，结束现在Hibernate，TopLink，JDO等ORM框架各自为营的局面。值得注意的是，Jpa是在充分吸收了现有Hibe
    
                    
    • 
                    
  • springboot日常开发参数校验注解
                        听忆.
日常开发mysqljava数据库
                        
    springboot日常开发参数校验注解1.常用的参数校验注解2.使用示例3.在Controller中使用4.全局异常处理5.自定义校验注解边走、边悟迟早会好在SpringBoot的日常开发中，常常使用参数校验注解来保证传入的数据符合业务逻辑或预期格式。SpringBoot内置了对JSR-303和JSR-380标准的支持，主要依赖javax.validation和HibernateValidato
    
                    
    • 
                    
  • mysql报错1785_MYSQL Statement violates GTID consistency: Updates to non-transactional tables can only ...
                        张观鱼
mysql报错1785
                        
    [2019-04-2110:17:20][ERROR][org.hibernate.engine.jdbc.spi.SqlExceptionHelper:144]StatementviolatesGTIDconsistency:Updatestonon-transactionaltablescanonlybedoneineitherautocommittedstatementsorsingle-s
    
                    
    • 
                    
  • SpringBoot2快速入门05--jpa
                        老鼠AI大米_Java全栈

                        
    本节我们学习使用Jpa，jpa其实是一个规范，在出来之前，都是使用hibernate，hibernate可以使程序员以面向对象的方式操作数据库，我还是喜欢nativesql。先导入相关包，如下：compile('org.springframework.boot:spring-boot-starter-data-jpa')compile('mysql:mysql-connector-java')配置
    
                    
    • 
                    
  • JPA简介与实战
                        是Guava不是瓜娃
SSMjpa
                        
    一、什么是JPAJPA：JavaPersistenceAPI，Java持久层API。是JDK5.0注解或XML描述对象－关系表的映射关系，并将运行期的实体对象持久化到数据库中。类似于JDBC，JPA是一组规范（接口），使应用程序以统一方式访问持久层。具体的实现：HibernateToplink其他ORM框架JPA和Hibernate的关系JPA是规范：JPA本质上就是一种ORM规范，不是ORM框架
    
                    
    • 
                    
  • Hibernate Session在项目中的创建方式
                        jingde528
Hibernatejavahibernate前端java
                        
    创建一个单例模式工具类，再通过在Hibernate配置文件中开启Session的线程管理模式的方法单例模式工具类packagetest.hibernate.spring.dao;importorg.hibernate.Session;importorg.hibernate.SessionFactory;importorg.hibernate.boot.MetadataSources;importo
    
                    
    • 
                    
  • Hibernate的检索策略(lazy、fetch、batch-size)
                        jingde528
Hibernatehibernatebatchjava
                        
    Hibernate的检索策略包括立即检索和延迟检索，可以在配置文件中通过对lazy、fetch、batch-size属性的设置来进行控制。一对多、多对多、多对一和一对一关系下的不同检索策略将影响对数据库访问的效率。检索策略立即检索，立即加载检索方法指定的对象延迟检索，延迟加载检索方法指定的对象，在使用具体属性值时，才进行加载(这个时候会执行查询语句)检索策略使用场景如果加载对象是为了访问他的属性，
    
                    
    • 
                    
  • JAVA Web学习(22)___第16章Hibernate技术
                        岁月静好浅笑安然

                        
    第16章Hibernate技术16.1初识Hibernate16.1.1理解ORM原理16.1.2Hibernate简介Hibernate是一款免费开源的持久层框架，它对JDBC进行了轻量级的对象封装，将对象与数据库表建立了映射关系，使Java编程人员可以随心所欲地使用面向对象的编程思想操作数据库。Hibernate具有简单易用、灵活性强、扩展性强等特点，大大提高了程序的开发效率。使用传统的JDB
    
                    
    • 
                    
  • Java编程开发新手学习：数组方法的应用猜字母游戏
                        Java小辰

                        
    Java是一种可以撰写跨平台应用软件的面向对象的程序设计语言。Java技术具有卓越的通用性、高效性、平台移植性和安全性，广泛应用于PC、数据中心、游戏控制台、科学超级计算机、移动电话和互联网，同时拥有全球最大的开发者专业社群。给你学习路线：html-css-js-jq-javase-数据库-jsp-servlet-Struts2-hibernate-mybatis-spring4-springmv
    
                    
    • 
                    
  • Spring Data：JPA与Querydsl
                        光图强
java
                        
    JPAJPA是java的一个规范，用于在java对象和数据库之间保存数据，充当面向对象领域模型和数据库之间的桥梁。它使用Hibernate、TopLink、IBatis等ORM框架实现持久性规范。SpringDataSpringData是Spring的一个子项目，用于简化数据库访问，支持NoSql数据和关系数据库。支持的NoSql数据库包括：Mongodb、redis、Hbase、Neo4j。Sp
    
                    
    • 
                    
  • @Autowired获取配置文件中被注入实例的两种方式
                        weixin_30719711
java
                        
    一、说明二、那么在JavaBean中如何通过@Autowired获取该实例呢？有两种方式：1.直接获取@RunWith(SpringJUnit4ClassRunner.class)@ContextConfiguration("classpath:applicationContext_test.xml")publicclassMyTest1{@AutowiredprivateHibernateTem
    
                    
    • 
                    
  • Java Hibernate深度解析：11步精通ORM框架的艺术与安全
                        墨瑾轩
Java乐园javahibernate安全
                        
    关注墨瑾轩，带你探索编程的奥秘！超萌技术攻略，轻松晋级编程高手技术宝库已备好，就等你来挖掘订阅墨瑾轩，智趣学习不孤单即刻启航，编程之旅更有趣第1章：引言：JPA与Hibernate的邂逅1.1什么是JPA？Hey，小伙伴们，欢迎来到JPA的奇妙世界！JPA，全称JavaPersistenceAPI，是一个让Java程序和数据库愉快玩耍的桥梁。想象一下，你有一个装满玩具的盒子，JPA就是帮你把玩具（
    
                    
    • 
                    
  • 手写Spring框架，加深对Spring工作机制的理解！
                        Java提升营

                        
    在我们的日常工作中，经常会用到Spring、SpringBoot、SpringCloud、Struts、Mybatis、Hibernate等开源框架，有了这些框架的诞生，平时的开发工作量也是变得越来越轻松，我们用SpringBoot分分钟可以新建一个Web项目。记得自己刚开始工作的时候还是在用Servlet写Web项目，自己写数据库连接池，用原生JDBC操作数据库，好了不发散了。回到这篇文章的主题
    
                    
    • 
                    
  • 现在程序员这么多，我学习java这块应该学到什么程度才能不被淘汰呢？
                        渡你眉间山河

                        
    一、夯实基础JavaSE这是基础，一定要好好学习！Java语法，面向对象（包括类、对象、方法、继承、封装、抽象、多态、消息解析等），常见API，数据结构，集合框架，设计模式（包括创建型、结构型、行为型），多线程和并发，I/O流，Stream，网络编程。JavaEEJavaEE是在JavaSE的基础上构建的，JavaEE容器，Web容器，常用框架（包括Struts2、Hibernate、Mybati
    
                    
    • 
                    
  • SpringBoot JPA
                        Puny丶微芒

                        
    定义JPA是JavaPersistenceAPI的简称，中文名Java持久层API，是JDK5.0注解或XML描述对象－关系表的映射关系，并将运行期的实体对象持久化到数据库中。JPA的总体思想和现有Hibernate、TopLink、JDO等ORM框架大体一致。总的来说，JPA包括以下3方面的技术：1.ORM映射元数据JPA支持XML和JDK注解两种元数据的形式，元数据描述对象和表之间的映射关系，
    
                    
    • 
                    
  • 什么是hql以及hql和sql的区别
                        m0_48680499

                        
    一、hql的定义Hibernate查询语言（HQL）是一种面向对象的查询语言，类似于SQL，但不是去对表和列进行操作，而是面向对象和它们的属性。二、HQL1.HQL里面的类名和属性名区分大小写，但关键字不区分大小写2.?从下标0开始计算位置3.HQL支持:命名参数4.HQL是面向对象的查询语言三、SQL1.SQL里面的表名和列名不区分大小写2.?从顺序1开始计算位置3.SQL不支持:命名参数4.S
    
                    
    • 
                    
  • 关于springboot持久层框架mybatis+jpa组合使用
                        小码农吗
日常栏目javamybatisspringbootmysql
                        
    一、简介JPA和MyBatis各有各的好处，混合食用效果更佳。(hibernate是面向对象的，而MyBatis是面向关系的)个人总结（总结自己的理解）1.表关联较多的项目，优先使用mybatis2.持续维护开发迭代较快的项目建议使用mybatis，因为一般这种项目需要变化很灵活，对sql的灵活修改要求较高3.对于传统项目或者关系模型较为清晰稳定的项目，建议JPA（比如DDD设计中的领域层）4.目
    
                    
    • 
                    
  • java批量导入和批量删除_Hibernate批处理操作优化 (批量插入、更新与删除)
                        林落年
java批量导入和批量删除
                        
    问题描述我开发的网站加了个新功能：需要在线上处理表数据的批量合并和更新，昨天下午发布上线，执行该功能后，服务器的load突然增高，变化曲线异常，SA教育了我一番，让我尽快处理，将CPU负载降低。工作所需，我经常要写些程序批量处理数据，每次执行几十万数据处理的时候，我机子的CPU都会飙高，而且数据处理速度会越来越慢。比如第一个1W条要5分钟，第二个1W条就要10分钟，要干其他事情的时候机子也卡的不行
    
                    
    • 
                    
  • mysql jdbc批量更新_Hibernate+JDBC实现批量插入、更新及删除的方法详解
                        weixin_39524147
mysqljdbc批量更新
                        
    本文实例讲述了HibernateJDBC实现批量插入、更新及删除的方法。分享给大家供大家参考，具体如下：一、批量插入(两种方式)1.通过Hibernate缓存如果这样写代码进行批量插入(初始设想)：packagecom.anlw.util;importorg.hibernate.Session;importorg.hibernate.SessionFactory;importorg.hiberna
    
                    
    • 
                    
  • Python之路：Django进阶篇
                        中國颜值的半壁江山
djangodjango
                        
    Modeldjango为使用一种新的方式，即：关系对象映射（ObjectRelationalMapping，简称ORM）。PHP：activerecordJava：HibernateC#：EntityFrameworkdjango中遵循CodeFrist的原则，即：根据代码中定义的类来自动生成数据库表。一、创建表1、基本结构fromdjango.dbimportmodels#Createyourm
    
                    
    • 
                                
  • 遍历dom 并且存储（将每一层的DOM元素存在数组中）
                                    换个号韩国红果果
JavaScripthtml
                                    
    数组从0开始！！ 
 


var a=[],i=0;
for(var j=0;j<30;j++){
		a[j]=[];//数组里套数组，且第i层存储在第a[i]中
	}

function walkDOM(n){
	
			do{
			if(n.nodeType!==3)//筛选去除#text类型

			a[i].push(n);
			
			//con
    
                                
    • 
                                
  • Android+Jquery Mobile学习系列(9)-总结和代码分享
                                    白糖_
JQuery Mobile
                                    
    目录导航 
  
经过一个多月的边学习边练手，学会了Android基于Web开发的毛皮，其实开发过程中用Android原生API不是很多，更多的是HTML/Javascript/Css。 
  
个人觉得基于WebView的Jquery Mobile开发有以下优点： 
1、对于刚从Java Web转型过来的同学非常适合，只要懂得HTML开发就可以上手做事。 
2、jquerym
    
                                
    • 
                                
  • impala参考资料
                                    dayutianfei
impala
                                    
    记录一些有用的Impala资料 
  
1. 入门资料 
>>官网翻译： 
    http://my.oschina.net/weiqingbin/blog?catalog=423691 
  
2. 实用进阶 
>>代码&架构分析： 
    Impala/Hive现状分析与前景展望：http
    
                                
    • 
                                
  • JAVA 静态变量与非静态变量初始化顺序之新解
                                    周凡杨
java静态非静态顺序
                                    
    今天和同事争论一问题，关于静态变量与非静态变量的初始化顺序，谁先谁后，最终想整理出来！测试代码： 
import java.util.Map;

public class T {

	public static T t = new T();
	private Map map = new HashMap();
	public T(){
		System.out.println(&quo
    
                                
    • 
                                
  • 跳出iframe返回外层页面
                                    g21121
iframe
                                    
    在web开发过程中难免要用到iframe，但当连接超时或跳转到公共页面时就会出现超时页面显示在iframe中，这时我们就需要跳出这个iframe到达一个公共页面去。 
首先跳转到一个中间页，这个页面用于判断是否在iframe中，在页面加载的过程中调用如下代码： 
<script type="text/javascript">
//<!--
function
    
                                
    • 
                                
  • JAVA多线程监听JMS、MQ队列
                                    510888780
java多线程
                                    
    背景：消息队列中有非常多的消息需要处理，并且监听器onMessage（）方法中的业务逻辑也相对比较复杂，为了加快队列消息的读取、处理速度。可以通过加快读取速度和加快处理速度来考虑。因此从这两个方面都使用多线程来处理。对于消息处理的业务处理逻辑用线程池来做。对于加快消息监听读取速度可以使用1.使用多个监听器监听一个队列；2.使用一个监听器开启多线程监听。 
对于上面提到的方法2使用一个监听器开启多线
    
                                
    • 
                                
  • 第一个SpringMvc例子
                                    布衣凌宇
spring mvc
                                    
    第一步：导入需要的包； 
第二步：配置web.xml文件 
 
<?xml version="1.0" encoding="UTF-8"?> 
<web-app version="2.5" 
 xmlns="http://java.sun.com/xml/ns/javaee" 
 xmlns:xsi=
    
                                
    • 
                                
  • 我的spring学习笔记15-容器扩展点之PropertyOverrideConfigurer
                                    aijuans
Spring3
                                    
    PropertyOverrideConfigurer类似于PropertyPlaceholderConfigurer，但是与后者相比，前者对于bean属性可以有缺省值或者根本没有值。也就是说如果properties文件中没有某个bean属性的内容，那么将使用上下文（配置的xml文件）中相应定义的值。如果properties文件中有bean属性的内容，那么就用properties文件中的值来代替上下
    
                                
    • 
                                
  • 通过XSD验证XML
                                    antlove
xmlschemaxsdvalidationSchemaFactory
                                    
    1. XmlValidation.java 
package xml.validation;

import java.io.InputStream;

import javax.xml.XMLConstants;
import javax.xml.transform.stream.StreamSource;
import javax.xml.validation.Schem
    
                                
    • 
                                
  • 文本流与字符集
                                    百合不是茶
PrintWrite()的使用字符集名字 别名获取
                                    
    文本数据的输入输出; 
          输入;数据流,缓冲流 
  
      输出;介绍向文本打印格式化的输出PrintWrite(); 
  
package 文本流;

import java.io.FileNotFound
    
                                
    • 
                                
  • ibatis模糊查询sqlmap-mapping-**.xml配置
                                    bijian1013
ibatis
                                    
            正常我们写ibatis的sqlmap-mapping-*.xml文件时，传入的参数都用##标识，如下所示： 
<resultMap id="personInfo" class="com.bijian.study.dto.PersonDTO">
	<res
    
                                
    • 
                                
  • java jvm常用命令工具——jdb命令(The Java Debugger)
                                    bijian1013
javajvmjdb
                                    
            用来对core文件和正在运行的Java进程进行实时地调试，里面包含了丰富的命令帮助您进行调试，它的功能和Sun studio里面所带的dbx非常相似，但 jdb是专门用来针对Java应用程序的。 
        现在应该说日常的开发中很少用到JDB了，因为现在的IDE已经帮我们封装好了，如使用ECLI
    
                                
    • 
                                
  • 【Spring框架二】Spring常用注解之Component、Repository、Service和Controller注解
                                    bit1129
controller
                                    
    在Spring常用注解第一步部分【Spring框架一】Spring常用注解之Autowired和Resource注解（http://bit1129.iteye.com/blog/2114084）中介绍了Autowired和Resource两个注解的功能，它们用于将依赖根据名称或者类型进行自动的注入，这简化了在XML中，依赖注入部分的XML的编写，但是UserDao和UserService两个bea
    
                                
    • 
                                
  • cxf wsdl2java生成代码super出错,构造函数不匹配
                                    bitray
super
                                    
        由于过去对于soap协议的cxf接触的不是很多,所以遇到了也是迷糊了一会.后来经过查找资料才得以解决. 初始原因一般是由于jaxws2.2规范和jdk6及以上不兼容导致的.所以要强制降为jaxws2.1进行编译生成.我们需要少量的修改: 
 
我们原来的代码 
wsdl2java com.test.xxx -client http://..... 
修改后的代
    
                                
    • 
                                
  • 动态页面正文部分中文乱码排障一例
                                    ronin47

                                    
    公司网站一部分动态页面，早先使用apache+resin的架构运行，考虑到高并发访问下的响应性能问题，在前不久逐步开始用nginx替换掉了apache。 不过随后发现了一个问题，随意进入某一有分页的网页，第一页是正常的（因为静态化过了）；点“下一页”，出来的页面两边正常，中间部分的标题、关键字等也正常，唯独每个标题下的正文无法正常显示。 因为有做过系统调整，所以第一反应就是新上
    
                                
    • 
                                
  • java-54- 调整数组顺序使奇数位于偶数前面
                                    bylijinnan
java
                                    
    
import java.util.Arrays;
import java.util.Random;

import ljn.help.Helper;


public class OddBeforeEven {

	/**
	 * Q 54 调整数组顺序使奇数位于偶数前面
	 * 输入一个整数数组，调整数组中数字的顺序，使得所有奇数位于数组的前半部分，所有偶数位于数组的后半
    
                                
    • 
                                
  • 从100PV到1亿级PV网站架构演变
                                    cfyme
网站架构
                                    
    一个网站就像一个人，存在一个从小到大的过程。养一个网站和养一个人一样，不同时期需要不同的方法，不同的方法下有共同的原则。本文结合我自已14年网站人的经历记录一些架构演变中的体会。 1：积累是必不可少的 
架构师不是一天练成的。 
1999年，我作了一个个人主页，在学校内的虚拟空间，参加了一次主页大赛，几个DREAMWEAVER的页面，几个TABLE作布局，一个DB连接，几行PHP的代码嵌入在HTM
    
                                
    • 
                                
  • [宇宙时代]宇宙时代的GIS是什么？
                                    comsci
Gis
                                    
     
 
       我们都知道一个事实，在行星内部的时候，因为地理信息的坐标都是相对固定的，所以我们获取一组GIS数据之后，就可以存储到硬盘中，长久使用。。。但是，请注意，这种经验在宇宙时代是不能够被继续使用的 
 
 
         宇宙是一个高维时空
    
                                
    • 
                                
  • 详解create database命令
                                    czmmiao
database
                                    
    完整命令 
CREATE DATABASE mynewdb   USER SYS IDENTIFIED BY sys_password   USER SYSTEM IDENTIFIED BY system_password   LOGFILE GROUP 1 ('/u01/logs/my/redo01a.log','/u02/logs/m
    
                                
    • 
                                
  • 几句不中听却不得不认可的话
                                    datageek

                                    
    1、人丑就该多读书。 
2、你不快乐是因为：你可以像猪一样懒，却无法像只猪一样懒得心安理得。 
3、如果你太在意别人的看法，那么你的生活将变成一件裤衩，别人放什么屁，你都得接着。 
4、你的问题主要在于：读书不多而买书太多，读书太少又特爱思考，还他妈话痨。 
5、与禽兽搏斗的三种结局：(1)、赢了，比禽兽还禽兽。(2)、输了，禽兽不如。(3)、平了，跟禽兽没两样。结论：选择正确的对手很重要。 
6
    
                                
    • 
                                
  • 1 14:00 PHP中的“syntax error, unexpected T_PAAMAYIM_NEKUDOTAYIM”错误
                                    dcj3sjt126com
PHP
                                    
    原文地址：http://www.kafka0102.com/2010/08/281.html 
  
因为需要，今天晚些在本机使用PHP做些测试，PHP脚本依赖了一堆我也不清楚做什么用的库。结果一跑起来，就报出类似下面的错误：“Parse error: syntax error, unexpected T_PAAMAYIM_NEKUDOTAYIM in /home/kafka/test/
    
                                
    • 
                                
  • xcode6 Auto layout and size classes
                                    dcj3sjt126com
ios
                                    
    官方GUI 
  
https://developer.apple.com/library/ios/documentation/UserExperience/Conceptual/AutolayoutPG/Introduction/Introduction.html 
  
iOS中使用自动布局（一） 
  
http://www.cocoachina.com/ind
    
                                
    • 
                                
  • 通过PreparedStatement批量执行sql语句【sql语句相同，值不同】
                                    梦见x光
sql事务批量执行
                                    
    比如说：我有一个List需要添加到数据库中，那么我该如何通过PreparedStatement来操作呢？ 
public void addCustomerByCommit(Connection conn , List<Customer> customerList) 
{ 
   String sql = "inseret into customer(id 
    
                                
    • 
                                
  • 程序员必知必会----linux常用命令之十【系统相关】
                                    hanqunfeng
Linux常用命令
                                    
    一.linux快捷键 
Ctrl+C : 终止当前命令 
Ctrl+S : 暂停屏幕输出 
Ctrl+Q : 恢复屏幕输出 
Ctrl+U : 删除当前行光标前的所有字符 
Ctrl+Z : 挂起当前正在执行的进程 
Ctrl+L : 清除终端屏幕，相当于clear 
  
二.终端命令 
clear : 清除终端屏幕 
reset : 重置视窗，当屏幕编码混乱时使用 
time com
    
                                
    • 
                                
  • NGINX
                                    IXHONG
nginx
                                    
    pcre 编译安装 nginx 
conf/vhost/test.conf 
  
upstream admin { 
server 127.0.0.1:8080; 
} 
  
server { 
                listen       80; 
&
    
                                
    • 
                                
  • 设计模式--工厂模式
                                    kerryg
设计模式
                                    
    工厂方式模式分为三种： 
  1、普通工厂模式：建立一个工厂类，对实现了同一个接口的一些类进行实例的创建。 
 
  2、多个工厂方法的模式：就是对普通工厂方法模式的改进，在普通工厂方法模式中，如果传递的字符串出错，则不能正确创建对象，而多个工厂方法模式就是提供多个工厂方法，分别创建对象。 
 
  3、静态工厂方法模式：就是将上面的多个工厂方法模式里的方法置为静态，
    
                                
    • 
                                
  • Spring InitializingBean/init-method和DisposableBean/destroy-method
                                    mx_xiehd
javaspringbeanxml
                                    
    1.initializingBean/init-method 
实现org.springframework.beans.factory.InitializingBean接口允许一个bean在它的所有必须属性被BeanFactory设置后，来执行初始化的工作，InitialzingBean仅仅指定了一个方法。 
通常InitializingBean接口的使用是能够被避免的，（不鼓励使用，因为没有必要
    
                                
    • 
                                
  • 解决Centos下vim粘贴内容格式混乱问题
                                    qindongliang1922
centosvim
                                    
     
 
有时候，我们在向vim打开的一个xml，或者任意文件中，拷贝粘贴的代码时，格式莫名其毛的就混乱了，然后自己一个个再重新，把格式排列好，非常耗时，而且很不爽，那么有没有办法避免呢？  答案是肯定的，设置下缩进格式就可以了，非常简单：  在用户的根目录下 直接vi  ~/.vimrc文件 然后将set pastetoggle=<F9> 写入这个文件中，保存退出，重新登录，
    
                                
    • 
                                
  • netty大并发请求问题
                                    tianzhihehe
netty
                                    
    多线程并发使用同一个channel 
java.nio.BufferOverflowException: null 
at java.nio.HeapByteBuffer.put(HeapByteBuffer.java:183) ~[na:1.7.0_60-ea] 
at java.nio.ByteBuffer.put(ByteBuffer.java:832) ~[na:1.7.0_60-ea] 
    
                                
    • 
                                
  • Hadoop NameNode单点问题解决方案之一 AvatarNode
                                    wyz2009107220
NameNode
                                    
    我们遇到的情况 
Hadoop NameNode存在单点问题。这个问题会影响分布式平台24*7运行。先说说我们的情况吧。 
我们的团队负责管理一个1200节点的集群(总大小12PB)，目前是运行版本为Hadoop 0.20，transaction logs写入一个共享的NFS filer(注：NetApp NFS Filer)。 
经常遇到需要中断服务的问题是给hadoop打补丁。 DataNod
    
                                
    •