缓存(查询优化)

最新推荐文章于 2024-07-01 11:10:23 发布
最新推荐文章于 2024-07-01 11:10:23 发布
阅读量173 收藏
点赞数
分类专栏： Hibernate 文章标签： Hibernate SQL XML junit 配置管理
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/iteye_3043/article/details/82039617
版权
1)hibernate一级缓存：一级缓存很短和session的生命周期一致，一级缓存也叫session级的缓存或事务级缓存

那些方法支持一级缓存：
* get()
* load()
* iterate（查询实体对象）

如何管理一级缓存：(一级缓存无法取消)
* session.clear(),session.evict()

如何避免一次性大量的实体数据入库导致内存溢出
* 先flush，再clear

如果数据量特别大，考虑采用jdbc实现，如果jdbc也不能满足要求可以考虑采用数据本身的特定导入工具 
// test
import java.io.Serializable;

import org.hibernate.Session;

import junit.framework.TestCase;

public class CacheLevel1Test extends TestCase {

	/**
	 * 在同一个session中发出两次load查询
	 */
	public void testCache1() {
		Session session = null;
		try {
			session = HibernateUtils.getSession();
			session.beginTransaction();

			Student student = (Student) session.load(Student.class, 2);
			System.out.println("student.name=" + student.getName());

			// 不会发出sql，因为load使用缓存
			student = (Student) session.load(Student.class, 2);
			System.out.println("student.name=" + student.getName());

			session.getTransaction().commit();
		} catch (Exception e) {
			e.printStackTrace();
			session.getTransaction().rollback();
		} finally {
			HibernateUtils.closeSession(session);
		}
	}

	/**
	 * 在同一个session中发出两次get查询
	 */
	public void testCache2() {
		Session session = null;
		try {
			session = HibernateUtils.getSession();
			session.beginTransaction();

			Student student = (Student) session.get(Student.class, 1);
			System.out.println("student.name=" + student.getName());

			// 不会发出sql，因为get使用缓存
			student = (Student) session.get(Student.class, 1);
			System.out.println("student.name=" + student.getName());

			session.getTransaction().commit();
		} catch (Exception e) {
			e.printStackTrace();
			session.getTransaction().rollback();
		} finally {
			HibernateUtils.closeSession(session);
		}
	}

	/**
	 * 在同一个session中发出两次iterate查询实体对象
	 */
	public void testCache3() {
		Session session = null;
		try {
			session = HibernateUtils.getSession();
			session.beginTransaction();

			Student student = (Student) session.createQuery(
					"from Student s where s.id=1").iterate().next();
			System.out.println("student.name=" + student.getName());

			// 会发出查询id的sql，不会发出查询实体对象的sql，因为iterate使用缓存
			student = (Student) session.createQuery(
					"from Student s where s.id=1").iterate().next();
			System.out.println("student.name=" + student.getName());

			session.getTransaction().commit();
		} catch (Exception e) {
			e.printStackTrace();
			session.getTransaction().rollback();
		} finally {
			HibernateUtils.closeSession(session);
		}
	}

	/**
	 * 在同一个session中发出两次iterate查询普通属性
	 */
	public void testCache4() {
		Session session = null;
		try {
			session = HibernateUtils.getSession();
			session.beginTransaction();

			String name = (String) session.createQuery(
					"select s.name from Student s where s.id=0").iterate()
					.next();
			System.out.println("student.name=" + name);

			// iterate查询普通属性，一级缓存不会缓存，所以发出sql
			// 一级缓存是缓存实体对象的
			name = (String) session.createQuery(
					"select s.name from Student s where s.id=1").iterate()
					.next();
			System.out.println("student.name=" + name);

			session.getTransaction().commit();
		} catch (Exception e) {
			e.printStackTrace();
			session.getTransaction().rollback();
		} finally {
			HibernateUtils.closeSession(session);
		}
	}

	/**
	 * 开启两个session中发出load查询
	 */
	public void testCache5() {
		Session session = null;
		try {
			session = HibernateUtils.getSession();
			session.beginTransaction();

			Student student = (Student) session.load(Student.class, 1);
			System.out.println("student.name=" + student.getName());

			session.getTransaction().commit();
		} catch (Exception e) {
			e.printStackTrace();
			session.getTransaction().rollback();
		} finally {
			HibernateUtils.closeSession(session);
		}

		try {
			session = HibernateUtils.getSession();
			session.beginTransaction();

			// 会发出查询语句，session间不能共享一级缓存的数据
			// 因为它会伴随session的生命周期存在和消亡
			Student student = (Student) session.load(Student.class, 1);
			System.out.println("student.name=" + student.getName());

			session.getTransaction().commit();
		} catch (Exception e) {
			e.printStackTrace();
			session.getTransaction().rollback();
		} finally {
			HibernateUtils.closeSession(session);
		}
	}

	/**
	 * 在同一个session中先save，在发出load查询save过的数据
	 */
	public void testCache6() {
		Session session = null;
		try {
			session = HibernateUtils.getSession();
			session.beginTransaction();

			Student stu = new Student();
			stu.setName("王五");

			Serializable id = session.save(stu); // 存储时返回序列化id

			// 不会发出sql，因为save是使用缓存的
			Student student = (Student) session.load(Student.class, id);
			System.out.println("student.name=" + student.getName());

			session.getTransaction().commit();
		} catch (Exception e) {
			e.printStackTrace();
			session.getTransaction().rollback();
		} finally {
			HibernateUtils.closeSession(session);
		}
	}

	/**
	 * 向数据库中批量加入1000条数据
	 */
	public void testCache7() {
		Session session = null;
		try {
			session = HibernateUtils.getSession();
			session.beginTransaction();

			for (int i = 0; i < 1000; i++) {
				Student student = new Student();
				student.setName("s_" + i);
				session.save(student);
				// 每20条数据就强制session将数据持久化
				// 同时清除缓存，避免大量数据造成内存溢出
				if (i % 20 == 0) {
					session.flush();
					session.clear();
				}
			}

			session.getTransaction().commit();
		} catch (Exception e) {
			e.printStackTrace();
			session.getTransaction().rollback();
		} finally {
			HibernateUtils.closeSession(session);
		}
	}
}

2)hibernate二级缓存：二级缓存也称进程级的缓存或SessionFactory级的缓存，二级缓存可以被所有的session共享；二级缓存的生命周期和SessionFactory的生命周期一致，SessionFactory可以管理二级缓存

二级缓存的配置和使用：
* 将echcache.xml文件拷贝到src下
* 开启二级缓存，修改hibernate.cfg.xml文件 
<property name="hibernate.cache.use_second_level_cache">true</property>

* 指定缓存产品提供商，修改hibernate.cfg.xml文件 
<property name="hibernate.cache.provider_class">org.hibernate.cache.EhCacheProvider</property>

* 指定那些实体类使用二级缓存（两种方法）
* 在映射文件中采用<cache>标签(Student.hbm.xml)
* 在hibernate.cfg.xml文件中，采用<class-cache>标签

二级缓存是缓存实体对象的

了解一级缓存和二级缓存的交互 
// test
import org.hibernate.CacheMode;
import org.hibernate.Session;
import org.hibernate.SessionFactory;

import junit.framework.TestCase;

public class CacheLevel2Test extends TestCase {

	/**
	 * 开启两个session，分别调用load
	 */
	public void testCache1() {
		Session session = null;
		try {
			session = HibernateUtils.getSession();
			session.beginTransaction();

			Student student = (Student) session.load(Student.class, 1);
			System.out.println("student.name=" + student.getName());

			session.getTransaction().commit();
		} catch (Exception e) {
			e.printStackTrace();
			session.getTransaction().rollback();
		} finally {
			HibernateUtils.closeSession(session);
		}

		try {
			session = HibernateUtils.getSession();
			session.beginTransaction();

			// 不会发出sql，因为开启了二级缓存，session是共享二级缓存的
			Student student = (Student) session.load(Student.class, 1);
			System.out.println("student.name=" + student.getName());

			session.getTransaction().commit();
		} catch (Exception e) {
			e.printStackTrace();
			session.getTransaction().rollback();
		} finally {
			HibernateUtils.closeSession(session);
		}

	}

	/**
	 * 开启两个session，分别调用get
	 */
	public void testCache2() {
		Session session = null;
		try {
			session = HibernateUtils.getSession();
			session.beginTransaction();

			Student student = (Student) session.get(Student.class, 1);
			System.out.println("student.name=" + student.getName());

			session.getTransaction().commit();
		} catch (Exception e) {
			e.printStackTrace();
			session.getTransaction().rollback();
		} finally {
			HibernateUtils.closeSession(session);
		}

		try {
			session = HibernateUtils.getSession();
			session.beginTransaction();

			// 不会发出sql，因为开启了二级缓存，session是共享二级缓存的
			Student student = (Student) session.get(Student.class, 1);
			System.out.println("student.name=" + student.getName());

			session.getTransaction().commit();
		} catch (Exception e) {
			e.printStackTrace();
			session.getTransaction().rollback();
		} finally {
			HibernateUtils.closeSession(session);
		}
	}

	/**
	 * 开启两个session，分别调用load,在使用SessionFactory清除二级缓存
	 */
	public void testCache3() {
		Session session = null;
		try {
			session = HibernateUtils.getSession();
			session.beginTransaction();

			Student student = (Student) session.load(Student.class, 1);
			System.out.println("student.name=" + student.getName());

			session.getTransaction().commit();
		} catch (Exception e) {
			e.printStackTrace();
			session.getTransaction().rollback();
		} finally {
			HibernateUtils.closeSession(session);
		}

		// SessionFactory管理二级缓存(SessionFactory级的缓存)
		SessionFactory factory = HibernateUtils.getSessionFactory();
		// factory.evict(Student.class); // 清除所有class对象
		factory.evict(Student.class, 1); // 清除指定class对象

		try {
			session = HibernateUtils.getSession();
			session.beginTransaction();

			// 会发出查询sql，因为二级缓存中的数据被清除了
			Student student = (Student) session.load(Student.class, 1);
			System.out.println("student.name=" + student.getName());

			session.getTransaction().commit();
		} catch (Exception e) {
			e.printStackTrace();
			session.getTransaction().rollback();
		} finally {
			HibernateUtils.closeSession(session);
		}
	}

	/**
	 * 一级缓存和二级缓存的交互
	 */
	public void testCache4() {
		Session session = null;
		try {
			session = HibernateUtils.getSession();
			session.beginTransaction();

			// 参数CacheMode是一个枚举参数
			// 仅向二级缓存读数据，而不向二级缓存写数据
			session.setCacheMode(CacheMode.GET); // 设置二级缓存的交互模式
			Student student = (Student) session.load(Student.class, 1);
			System.out.println("student.name=" + student.getName());

			session.getTransaction().commit();
		} catch (Exception e) {
			e.printStackTrace();
			session.getTransaction().rollback();
		} finally {
			HibernateUtils.closeSession(session);
		}

		try {
			session = HibernateUtils.getSession();
			session.beginTransaction();

			// 默认CacheMode，既可以写也会读，现在session中有数据了
			// 发出sql语句，因为session设置了CacheMode为GET，所以二级缓存中没有数据
			Student student = (Student) session.load(Student.class, 1);
			System.out.println("student.name=" + student.getName());

			session.getTransaction().commit();
		} catch (Exception e) {
			e.printStackTrace();
			session.getTransaction().rollback();
		} finally {
			HibernateUtils.closeSession(session);
		}

		try {
			session = HibernateUtils.getSession();
			session.beginTransaction();

			// 只向二级缓存写数据，而不从二级缓存读数据
			session.setCacheMode(CacheMode.PUT); // 设置二级缓存的交互模式

			// 会发出查询sql，因为session将CacheMode设置成了PUT
			Student student = (Student) session.load(Student.class, 1);
			System.out.println("student.name=" + student.getName());

			session.getTransaction().commit();
		} catch (Exception e) {
			e.printStackTrace();
			session.getTransaction().rollback();
		} finally {
			HibernateUtils.closeSession(session);
		}
	}
}

3)hibernate查询缓存：查询缓存是针对普通属性结果集的缓存，对实体对象的结果集只缓存id，查询缓存的生命周期，当前关联的表发生修改，那么查询缓存生命周期结束

查询缓存的配置和使用：
* 在hibernate.cfg.xml文件中启用查询缓存，如： 
<property name="hibernate.cache.use_query_cache">true</property>

* 在程序中必须手动启用查询缓存，如： 
// tset
import org.hibernate.Session;

public class InitData {

	public static void main(String[] args) {
			Session session = HibernateUtils.getSession();

			try {
				session.beginTransaction();

				for(int i=0; i<10; i++){

					Classes classes = new Classes();
					classes.setName("班级"+i);
					session.save(classes);

					for(int j=0; j<10; j++){
						Student student = new Student();
						student.setName("班级"+i+"的学生"+j);

						//在内存中建立由student指向classes的引用
						student.setClasses(classes);
						session.save(student);
					}
				}
				session.getTransaction().commit();
			} catch (Exception e) {
				e.printStackTrace();
				session.getTransaction().rollback();
			} finally{
				HibernateUtils.closeSession(session);
			}
		}	
}


import java.util.Iterator;
import java.util.List;

import org.hibernate.Query;
import org.hibernate.Session;
import junit.framework.TestCase;

public class CacheLevel2Test extends TestCase {

	/**
	 * 开启查询缓存，关闭二级缓存
	 * 
	 * 开启一个session，分别调用query.list查询普通属性
	 */
	public void testCache1() {
		Session session = null;
		try {
			session = HibernateUtils.getSession();
			session.beginTransaction();

			Query query = session.createQuery("select s.name from Student s");

			//手动启用查询查询缓存
			query.setCacheable(true);

			List names = query.list(); 
			for (Iterator iter=names.iterator();iter.hasNext(); ) {
				String name = (String)iter.next();
				System.out.println(name);
			}

			System.out.println("-------------------------------------");
			query = session.createQuery("select s.name from Student s");
			//启用查询查询缓存
			query.setCacheable(true);

			//没有发出查询sql，因为启用了查询缓存(缓存的是普通属性)
			names = query.list(); 
			for (Iterator iter=names.iterator();iter.hasNext(); ) {
				String name = (String)iter.next();
				System.out.println(name);
			}

			session.getTransaction().commit();
		}catch(Exception e) {
			e.printStackTrace();
			session.getTransaction().rollback();
		}finally {
			HibernateUtils.closeSession(session);
		}
	}	

	/**
	 * 开启查询缓存，关闭二级缓存
	 * 
	 * 开启两个session，分别调用query.list查询普通属性
	 */
	public void testCache2() {
		Session session = null;
		try {
			session = HibernateUtils.getSession();
			session.beginTransaction();

			Query query = session.createQuery("select s.name from Student s");
			//启用查询查询缓存
			query.setCacheable(true);

			List names = query.list(); 
			for (Iterator iter=names.iterator();iter.hasNext(); ) {
				String name = (String)iter.next();
				System.out.println(name);
			}
			session.getTransaction().commit();
		}catch(Exception e) {
			e.printStackTrace();
			session.getTransaction().rollback();
		}finally {
			HibernateUtils.closeSession(session);
		}

		System.out.println("-------------------------------------");

		try {
			session = HibernateUtils.getSession();
			session.beginTransaction();

			Query query = session.createQuery("select s.name from Student s");
			//启用查询查询缓存
			query.setCacheable(true);

			//不会发出查询sql，因为查询缓存的生命周期和session无关
			List names = query.list(); 
			for (Iterator iter=names.iterator();iter.hasNext(); ) {
				String name = (String)iter.next();
				System.out.println(name);
			}
			session.getTransaction().commit();
		}catch(Exception e) {
			e.printStackTrace();
			session.getTransaction().rollback();
		}finally {
			HibernateUtils.closeSession(session);
		}
	}		

	/**
	 * 开启查询缓存，关闭二级缓存
	 * 
	 * 开启两个session，分别调用query.iterate(迭代接口)查询普通属性
	 */
	public void testCache3() {
		Session session = null;
		try {
			session = HibernateUtils.getSession();
			session.beginTransaction();

			Query query = session.createQuery("select s.name from Student s");
			//启用查询查询缓存
			query.setCacheable(true);

			for (Iterator iter=query.iterate();iter.hasNext(); ) {
				String name = (String)iter.next();
				System.out.println(name);
			}
			session.getTransaction().commit();
		}catch(Exception e) {
			e.printStackTrace();
			session.getTransaction().rollback();
		}finally {
			HibernateUtils.closeSession(session);
		}

		System.out.println("-------------------------------------");

		try {
			session = HibernateUtils.getSession();
			session.beginTransaction();

			Query query = session.createQuery("select s.name from Student s");
			//启用查询查询缓存
			query.setCacheable(true);

			//查询缓存只对query.list()起作用，query.iterate不起作用
			//也就是query.iterate不使用查询缓存
			for (Iterator iter=query.iterate();iter.hasNext(); ) {
				String name = (String)iter.next();
				System.out.println(name);
			}
			session.getTransaction().commit();
		}catch(Exception e) {
			e.printStackTrace();
			session.getTransaction().rollback();
		}finally {
			HibernateUtils.closeSession(session);
		}
	}

	/**
	 * 关闭查询缓存，关闭二级缓存
	 * 
	 * 开启两个session，分别调用query.list查询实体对象
	 */
	public void testCache4() {
		Session session = null;
		try {
			session = HibernateUtils.getSession();
			session.beginTransaction();

			Query query = session.createQuery("select s from Student s");
			//启用查询查询缓存
			//query.setCacheable(true);

			List students = query.list(); 
			for (Iterator iter=students.iterator();iter.hasNext(); ) {
				Student student = (Student)iter.next();
				System.out.println(student.getName());
			}
			session.getTransaction().commit();
		}catch(Exception e) {
			e.printStackTrace();
			session.getTransaction().rollback();
		}finally {
			HibernateUtils.closeSession(session);
		}

		System.out.println("-------------------------------------");

		try {
			session = HibernateUtils.getSession();
			session.beginTransaction();

			Query query = session.createQuery("select s from Student s");
			//启用查询查询缓存
			//query.setCacheable(true);
			//会发出查询sql，因为list默认每次都会发出查询sql
			List students = query.list(); 
			for (Iterator iter=students.iterator();iter.hasNext(); ) {
				Student student = (Student)iter.next();
				System.out.println(student.getName());
			}
			session.getTransaction().commit();
		}catch(Exception e) {
			e.printStackTrace();
			session.getTransaction().rollback();
		}finally {
			HibernateUtils.closeSession(session);
		}
	}		

	/**
	 * 开启查询缓存，关闭二级缓存
	 * 
	 * 开启两个session，分别调用query.list查询实体对象
	 */
	public void testCache5() {
		Session session = null;
		try {
			session = HibernateUtils.getSession();
			session.beginTransaction();

			Query query = session.createQuery("select s from Student s");
			//启用查询查询缓存
			query.setCacheable(true);

			List students = query.list(); 
			for (Iterator iter=students.iterator();iter.hasNext(); ) {
				Student student = (Student)iter.next();
				System.out.println(student.getName());
			}
			session.getTransaction().commit();
		}catch(Exception e) {
			e.printStackTrace();
			session.getTransaction().rollback();
		}finally {
			HibernateUtils.closeSession(session);
		}

		System.out.println("-------------------------------------");

		try {
			session = HibernateUtils.getSession();
			session.beginTransaction();

			Query query = session.createQuery("select s from Student s");
			//启用查询查询缓存
			query.setCacheable(true);

			//会发出n条查询语句，因为开启了查询缓存，关闭了二级缓存，那么查询缓存会缓存实体对象的id
			//所以hibernate会根据实体对象的id去查询相应的实体，如果缓存中不存在相应的
			//实体那么将发出根据实体id查询的sql语句，否则不会发出sql使用缓存中的数据
			List students = query.list(); 
			for (Iterator iter=students.iterator();iter.hasNext(); ) {
				Student student = (Student)iter.next();
				System.out.println(student.getName());
			}
			session.getTransaction().commit();
		}catch(Exception e) {
			e.printStackTrace();
			session.getTransaction().rollback();
		}finally {
			HibernateUtils.closeSession(session);
		}
	}	

	/**
	 * 开启查询缓存，开启二级缓存
	 * 
	 * 开启两个session，分别调用query.list查询实体对象
	 */
	public void testCache6() {
		Session session = null;
		try {
			session = HibernateUtils.getSession();
			session.beginTransaction();

			Query query = session.createQuery("select s from Student s");
			//启用查询查询缓存
			query.setCacheable(true);

			List students = query.list(); 
			for (Iterator iter=students.iterator();iter.hasNext(); ) {
				Student student = (Student)iter.next();
				System.out.println(student.getName());
			}
			session.getTransaction().commit();
		}catch(Exception e) {
			e.printStackTrace();
			session.getTransaction().rollback();
		}finally {
			HibernateUtils.closeSession(session);
		}

		System.out.println("-------------------------------------");

		try {
			session = HibernateUtils.getSession();
			session.beginTransaction();

			Query query = session.createQuery("select s from Student s");
			//启用查询查询缓存
			query.setCacheable(true);

			//不会发出查询sql，因为开启了二级缓存和查询缓存，查询缓存缓存了实体对象的id列表
			//hibernate会根据实体对象的id列表到二级缓存中取得相应的数据
			List students = query.list(); 
			for (Iterator iter=students.iterator();iter.hasNext(); ) {
				Student student = (Student)iter.next();
				System.out.println(student.getName());
			}
			session.getTransaction().commit();
		}catch(Exception e) {
			e.printStackTrace();
			session.getTransaction().rollback();
		}finally {
			HibernateUtils.closeSession(session);
		}
	}		
}
query.setCacheable(true);
// model
import java.util.Set;

public class Classes {

	private int id;

	private String name;

	private Set<Student> students; 

	public int getId() {
		return id;
	}

	public void setId(int id) {
		this.id = id;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

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

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


public class Student {

	private int id;

	private String name;

	private Classes classes;

	public int getId() {
		return id;
	}

	public void setId(int id) {
		this.id = id;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public Classes getClasses() {
		return classes;
	}

	public void setClasses(Classes classes) {
		this.classes = classes;
	}
}
// hibernate.cfg.xml
<!-- 开启二级缓存,默认 -->
		<property name="hibernate.cache.use_second_level_cache">true</property>

		<!-- 指定缓存产品提供商 -->
		<property name="hibernate.cache.provider_class">org.hibernate.cache.EhCacheProvider</property>

		<!-- 启用查询缓存，默认关闭 -->
		<property name="hibernate.cache.use_query_cache">true</property>

		<mapping resource="com/bjsxt/hibernate/Classes.hbm.xml"/>
		<mapping resource="com/bjsxt/hibernate/Student.hbm.xml"/>

		<class-cache class="com.bjsxt.hibernate.Student" usage="read-only"/>
		<!-- 指定实体类使用二级缓存(推荐) -->


// Classes.hbm.xml
<hibernate-mapping package="com.bjsxt.hibernate">
	<class name="Classes" table="t_classes">
		<id name="id">
			<generator class="native"/>
		</id>
		<property name="name"/>
		<set name="students" inverse="true" cascade="all">
			<key column="classesid"/>
			<one-to-many class="Student"/>
		</set>
	</class>
</hibernate-mapping>


// Student.hbm.xml
<hibernate-mapping>
	<class name="com.bjsxt.hibernate.Student" table="t_student">
		<!-- 
		<cache usage="read-only"/>
		 --><!-- 指定实体类使用二级缓存 -->
		<id name="id">
			<generator class="native"/>
		</id>
		<property name="name"/>
		<many-to-one name="classes" column="classesid"/>
	</class>
</hibernate-mapping>
iteye_3043
关注
专栏目录
缓存性能的优化方法
weixin_34195364的博客
03-29 2081
基于 《计算机体系结构：量化研究方法》2.2 缓存性能的10种高级优化方法 因为CPU和主存的性能差距越来越大，所以在CPU和主存之间增加了多级高速缓存，如L1 cache、L2 cache，来提升性能。 缓存设计时需要考虑以下度量 命中时间：在缓存中找到指定的数据的时间。 缺失率：当缓存中未找到指定数据的概率。 缺失代价：当缓存未命中恢复到缓存命中的代价 功耗 缓存带宽 可以通过一些方法来针...
mysql查询优化-查询缓存
后端学习
08-27 276
mysql如何判断缓存是否命中 缓存使用的是一个引用表，通过一个哈希值的引用，这个哈希值包括了，当前要查询的数据库，客户端协议，查询本身等 当判断缓存是否命中时，mysql是不会解析，优化的，使用的是sql语句和客户端发送过来的原始信息。 所以任何字符上的不同，例如空格，注释等都会导致缓存不会命中（所以这就导致缓存命中的条件比较苛刻，不同的编码习惯，命中率的影响很大） 查询缓存如何使用内存 查询缓存是完全在内存当中，基本的管理维护数据结构大概需要40kb左右的内存资源 mysql用于查询缓存的内存被分
查询和缓存
Laurence的技术博客
06-10 4759
经过大量的测试，查询和缓存之间的关系已经基本上清楚了。1. 一次查询过后，结果集中的所有个体都会进入持久化上下文，也就是一级缓存中（如果打开了二级缓存，它们也同样会进入二级缓存）。这就是意味着后面的程序如果要load（不是查询）结果集中的任何一个对象都会从缓存中直接命中，不会生成任何SQL去Hit数据库。2. 但是作为结果集的整体，在不使用查询缓存的前提下是不会被缓存的。举个例子：当执行一个得到某个班级所有学生的查询后，这个班级所有的学生实例会被加载并进行入缓存中。但是缓存并没有缓存“这些学生都是某一个班级
关于MySQL缓存的查询和清除命令的详细指南
最新发布
My_wife_QBL的博客
07-01 2134
缓存（Cache）是一种临时存储机制，用于存储常用或最近访问的数据，以减少从磁盘读取数据的次数，从而加快数据访问速度。MySQL中常见的缓存包括查询缓存、表缓存和InnoDB缓冲池。查询缓存是MySQL中的一种缓存机制，用于存储SELECT查询语句及其结果集。通过查询缓存，MySQL可以直接返回缓存中的查询结果，而无需重新执行查询。表缓存（Table Cache）是MySQL用于存储表的元数据和相关信息的一种缓存机制。通过表缓存，MySQL可以减少表打开和关闭的开销，从而提高查询性能。
查询缓存---Mybatis学习笔记（十）
ZhangYaohui专栏
12-14 714
mybatis缓存介绍mybatis提供查询缓存，用于减轻数据压力，提高数据库性能。 如下图，是mybatis一级缓存和二级缓存的区别图解： Mybatis一级缓存的作用域是同一个SqlSession，在同一个sqlSession中两次执行相同的sql语句，第一次执行完毕会将数据库中查询的数据写到缓存（内存），第二次会从缓存中获取数据将不再从数据库查询，从而提高查询效率。当一个sqlSessio
查询缓存
weixin_33857230的博客
01-11 174
1、从Mysql4.0开始，支持查询缓存，把查询结果记录下来，遇到同样的查询直接返回，提高效率。2、query_cache_type 查询缓存是否开启 select @@query_cache_type; set @@query_cache_type=on;3、have_query_cache 已经可用 select @@have_query_cache; // 变量是...
缓存优化
qq_42266891的博客
09-23 1477
1、了解内存缓存 1. 1、什么是缓存 在计算中，缓存是一个高速数据存储层，其中存储了数据子集，且通常是短暂性存储，这样日后再次请求此数据时，速度要比访问数据的主存储位置快。通过缓存，可以高效地重用之前检索或计算的数据。缓存本质上是以空间换时间，提高接口的响应速度。 硬件 是指一块芯片被集成到硬盘或者CPU上，作用就是充当硬盘,CPU与外界的接口之间的一个暂存器。这里的外界接口通常是指硬盘和内存，或者是CPU与内存之间。利用缓存可以减轻系统的负载，同时提高传播效率。 客户端缓存 为了实现可以快速地响应用户的
CI框架数据库查询缓存优化的方法
10-21
以下是关于CI框架数据库查询缓存优化的详细讲解。 1. 开启缓存 要启用CI框架的数据库查询缓存，首先需要在配置文件`application/config.php`中设置`$db['default']['cache_on']`为`TRUE`，表示开启缓存功能。同时，...
MySQL数据库性能优化之缓存参数优化
01-31
在平时被问及最多的问题就是关于MySQL数据库性能优化方面的问题，所以最近打算写一个MySQL数据库性能...本文先从MySQL数据库IO相关参数(缓存参数)的角度来看看可以通过哪些参数进行IO优化：Querycache作用于整个MySQ
MySQL DBA教程：Mysql性能优化之缓存参数优化
12-15
MySQL 数据库性能优化是DBA工作中的核心任务之一，尤其对于IO密集型的数据库系统，内存缓存的优化显得尤为重要。本教程将聚焦于MySQL的缓存参数优化，旨在通过调整相关参数，最大化利用内存资源，减少磁盘IO，从而...
MySQL查询缓存优化
Sianel的博客
05-15 702
1. Mysql中查询缓存优化 1.1 概述 开启Mysql的查询缓存，当执行完全相同的SQL语句的时候，服务器就会直接从缓存中读取结果，当数据被修改，之前的缓存会失效，修改比较频繁的表不适合做查询缓存。 1.2 操作流程 客户端发送一条查询给服务器； 服务器先会检查查询缓存，如果命中了缓存，则立即返回存储在缓存中的结果。否则进入下一阶段； 服务器端进行SQL解析、预处理，再由优化器生成对应的执行计划； MySQL根据优化器生成的执行计划，调用存储引擎的API来执行查询； 将结果返回给客户端。 1.3
MySQL 查询缓存
weixin_30731305的博客
07-25 113
从 MySQL 4.0.1 开始，MySQL server 有一个重要的特征：Query Cache。 当在使用中，查询缓存会存储一个 SELECT 查询的文本与被传送到客户端的相应结果。如果之后接收到一个同样的查询，服务器将从查询缓存中检索结果，而不是再次分析和执行这个同样的查询。 注意：查询缓存绝不返回过期数据。当数据被修改后，在查询缓存中的任何相关词条均被转储清除。 在...
mysql 系统参数_MySQL 系统变量和系统状态参数详解
weixin_39927623的博客
01-18 100
1.查询缓存相关mysql>showvariableslike'%query_cache%';+------------------------------+----------+|Variable_name|Value|+------------------------------+----------+|have_query_cach...
开启查询缓存
Belle_Chou的博客
06-25 431
在cfg文件里要手动打开查询缓存 因为查询缓存默认是关闭的 并且在具体的createQuery语句中要将createCacheable（true） 且查询缓存只对listquery有效 （只发一条查询语句） 对iteratequery无效（仍然发两条，见下example） public void testload1(){ Session session=null; ...
缓存的使用，以及查询数据的优化
li814390253的博客
08-28 616
大家在实际项目应用的时候 ，查询数据，以及查询数据量，以及查询数据快慢是查询的关键。 所以在优化查询，提高查询效率就变成了重中之重，首先我们要了解查询所要经历的过程，首先是项目的编译启动，进程运行，用户访问，数据查询，数据的耗能，以及数据反馈等。 我这里只说能够用到的地方，以及本人知道的。如有更好的也请各位大神多多指教。 系统编译过程也...
mysql优化之查询缓存
大黄蜂的博客
05-14 352
前言 开启mysql缓存后，数据没有更新的情况下，相同的查询sql会使用缓存数据返回结果。在数据更新较少，类似查询较多的情况下，使用mysql缓存可以显著提升查询效率。 mysql查询缓存参数设置 have_query_cache表示是否支持查询缓存，YES表示支持 query_cache_type表示缓存类型，OFF表示关闭查询缓存，ON表示开启查询缓存，DEMAND表示用户自定义查询缓存 query_cache_limit表示支持的最大单条查询sql数据量 query_cache_min_res_u
PHP SQL查询缓存优化技术
"PHP查询缓存技术是一种优化网站性能的方法，通过将SQL查询结果存储在缓存中，避免频繁地连接数据库和执行查询，从而提高响应速度和减轻服务器负载。本教程面向熟悉PHP编程并希望了解如何利用缓存提升数据库性能的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值