Hibernate查询以及优化策略04
一. HQL查询
1. HQL（hibernate query language）单表查询
1.1 准备项目
创建项目: hinernate-03-query
引入jar,同前一个项目
复制实体(订单,客户),映射,配置,工具类.
1.2 HQL单表基本查询
/**
* 演示HQL的查询（单表查询）
* 1）全表查询
* 2）别名查询
* 3）条件查询
* 4）具名查询
* 5）分页查询
* 6）查询排序
* 7）聚合查询
* 8）投影查询
*/
public class HQLTest1 {
/**
* 全表查询
*/
@Test
public void test1(){
Session session = HibernateUtil.openSession();
Transaction tx = session.beginTransaction(); //注意：
//1、不能写 select * from Order
//2、Order是对象名，不是表名
Query<Order> query = session.createQuery("from Order", Order.class);
List<Order> list = query.list();
for (Order order : list) {
//为了避免空指针和内存溢出，toString打印时暂时不要打印order中的customer
System.out.println(order);
} tx.commit();
session.close();
} /**
* 别名查询
*/
@Test
public void test2(){
Session session = HibernateUtil.openSession();
Transaction tx = session.beginTransaction(); Query<Order> query = session.createQuery("select o from Order o", Order.class);
List<Order> list = query.list();
for (Order order : list) {
System.out.println(order);
} tx.commit();
session.close();
} /**
* 条件查询
*/
@Test
public void test31(){
Session session = HibernateUtil.openSession();
Transaction tx = session.beginTransaction(); Query<Order> query = session.createQuery("from Order where orderno = '201709070001'", Order.class);
List<Order> list = query.list();
for (Order order : list) {
System.out.println(order);
} tx.commit();
session.close();
} /**
* 条件查询2
*/
@Test
public void test32(){
Session session = HibernateUtil.openSession();
Transaction tx = session.beginTransaction(); Query<Order> query = session.createQuery("from Order where orderno = ?", Order.class);
query.setParameter(0, "201709070001");
List<Order> list = query.list();
for (Order order : list) {
System.out.println(order);
} tx.commit();
session.close();
} /**
* 具名查询
*/
@Test
public void test4(){
Session session = HibernateUtil.openSession();
Transaction tx = session.beginTransaction(); Query<Order> query = session.createQuery("from Order where orderno = :orderno", Order.class);
query.setParameter("orderno", "201709070001");
List<Order> list = query.list();
for (Order order : list) {
System.out.println(order);
} tx.commit();
session.close();
} /**
* 分页查询
*/
@Test
public void test5(){
Session session = HibernateUtil.openSession();
Transaction tx = session.beginTransaction(); Query<Order> query = session.createQuery("from Order", Order.class);
//设置起始行，从0开始
query.setFirstResult(2);
//设置查询行数
query.setMaxResults(2);
List<Order> list = query.list();
for (Order order : list) {
System.out.println(order);
} tx.commit();
session.close();
} /**
* 查询排序
*/
@Test
public void test6(){
Session session = HibernateUtil.openSession();
Transaction tx = session.beginTransaction(); Query<Order> query = session.createQuery("from Order order by id desc", Order.class);
List<Order> list = query.list();
for (Order order : list) {
System.out.println(order);
} tx.commit();
session.close();
} /**
* 聚合查询：同样也支持max、min、avg、sum等聚合函数
*/
@Test
public void test7(){
Session session = HibernateUtil.openSession();
Transaction tx = session.beginTransaction(); Query<Long> query = session.createQuery("select count(*) from Order", Long.class); /*List<Long> list = query.list();
Long count = list.get(0);
System.out.println(count);*/
Long count = query.uniqueResult();
System.out.println(count); tx.commit();
session.close();
} /**
* 投影查询（查询局部字段）
*/
@Test
public void test81(){
Session session = HibernateUtil.openSession();
Transaction tx = session.beginTransaction(); Query<Object[]> query = session.createQuery("select orderno,productName from Order", Object[].class);
List<Object[]> list = query.list();
for (Object[] objects : list) {
for (Object object : objects) {
System.out.print(object+"\t");
}
System.out.println();
} tx.commit();
session.close();
} /**
* 投影查询2（查询局部字段）
*/
@Test
public void test82(){
Session session = HibernateUtil.openSession();
Transaction tx = session.beginTransaction(); //注意创建对应的两个参数的构造方法
Query<Order> query = session.createQuery("select new com.qfedu.hibernate.pojo.Order(orderno,productName) from Order", Order.class);
List<Order> list = query.list();
for (Order order : list) {
System.out.println(order);
} tx.commit();
session.close();
}
}
2. HQL多表查询
2.1. 多表查询分类
1）内连接查询： inner join
2）左连接查询： left join
3）右连接查询：right join
2.2 HQL多表查询
需求: 同时显示客户名称和订单名称
/**
* 演示HQL的查询（多表查询）
* 1）内连接查询
* 2）左连接查询
* 3）右连接查询
*
*/
public class HQLTest2 { /**
* 内连接查询
* 效果：只会显示满足条件的数据
*/
@Test
public void test1(){
Session session = HibernateUtil.openSession();
Transaction tx = session.beginTransaction();
//需求：显示客户名称和订单产品名称
Query<Object[]> query = session.createQuery("select c.name,o.productName from Customer c inner join c.orders o", Object[].class);
List<Object[]> list = query.list();
for (Object[] objects : list) {
for (Object object : objects) {
System.out.print(object+"\t");
}
System.out.println();
}
tx.commit();
session.close();
} /**
* 左连接查询
* 效果：左边的数据全部显示
*/
@Test
public void test2(){
Session session = HibernateUtil.openSession();
Transaction tx = session.beginTransaction();
//需求：显示客户名称和订单产品名称
Query<Object[]> query = session.createQuery("select c.name,o.productName from Customer c left join c.orders o", Object[].class);
List<Object[]> list = query.list();
for (Object[] objects : list) {
for (Object object : objects) {
System.out.print(object+"\t");
}
System.out.println();
}
tx.commit();
session.close();
} /**
* 右连接查询
* 效果：右边的数据全部显示（和上个测试用例的效果一致）
*/
@Test
public void test3(){
Session session = HibernateUtil.openSession();
Transaction tx = session.beginTransaction();
//需求：显示客户名称和订单产品名称
Query<Object[]> query = session.createQuery("select c.name,o.productName from Order o right join o.customer c", Object[].class);
List<Object[]> list = query.list();
for (Object[] objects : list) {
for (Object object : objects) {
System.out.print(object+"\t");
}
System.out.println();
}
tx.commit();
session.close();
}
}
二. QBC查询
1. QBC查询介绍
Query By Criteria 使用 Criteria 对象进行查询
特点：面向对象方式的查询
注意：5.2版本以后被废弃，推荐使用 JPA Criteria
2. QBC查询测试
/**
* 演示Criteria的查询（单表查询）
* 1）全表查询
* 2）条件查询
* 3）分页查询
* 4）查询排序
* 5）聚合查询
* 6）投影查询
*
* //@deprecated (since 5.2) for Session, use the JPA Criteria
*/
public class QBCTest {
/**
* 全表查询
*/
@Test
public void test1(){
Session session = HibernateUtil.openSession();
Transaction tx = session.beginTransaction();
Criteria ce = session.createCriteria(Customer.class);
List<Customer> list = ce.list();
for (Customer customer : list) {
System.out.println(customer.getName());
}
tx.commit();
session.close();
} /**
* 条件查询
*/
@Test
public void test21(){
Session session = HibernateUtil.openSession();
Transaction tx = session.beginTransaction();
Criteria ce = session.createCriteria(Order.class);
//添加查询条件 orderno = '201709070002'
ce.add( Restrictions.eq("orderno", "201709070002") );
List<Order> list = ce.list();
for (Order order : list) {
System.out.println(order.getProductName());
}
tx.commit();
session.close();
} /**
* 条件查询2(多条件)
*/
@Test
public void test22(){
Session session = HibernateUtil.openSession();
Transaction tx = session.beginTransaction();
Criteria ce = session.createCriteria(Order.class);
//添加查询条件 orderno like '%2017%' and productName like '%JavaWeb%'
ce.add( Restrictions.and( Restrictions.like("orderno", "%2017%") , Restrictions.like("productName", "%JavaWeb%") ) );
List<Order> list = ce.list();
for (Order order : list) {
System.out.println(order.getProductName());
}
tx.commit();
session.close();
} /**
* 分页查询
*/
@Test
public void test3(){
Session session = HibernateUtil.openSession();
Transaction tx = session.beginTransaction();
Criteria ce = session.createCriteria(Order.class);
//分页查询
ce.setFirstResult(2);//起始行
ce.setMaxResults(2);//查询行数
List<Order> list = ce.list();
for (Order order : list) {
System.out.println(order.getProductName());
}
tx.commit();
session.close();
} /**
* 查询排序
*/
@Test
public void test4(){
Session session = HibernateUtil.openSession();
Transaction tx = session.beginTransaction();
Criteria ce = session.createCriteria(Order.class);
//排序 order by id desc
//因为我们的项目中也定义了Order类，所以这里的Order使用全名
ce.addOrder(org.hibernate.criterion.Order.desc("id"));
List<Order> list = ce.list();
for (Order order : list) {
System.out.println(order);
}
tx.commit();
session.close();
} /**
* 聚合查询
*/
@Test
public void test5(){
Session session = HibernateUtil.openSession();
Transaction tx = session.beginTransaction();
Criteria ce = session.createCriteria(Order.class);
//查询总记录数 select count(id)
//ce.setProjection(Projections.rowCount());
ce.setProjection(Projections.count("id"));
Long count = (Long)ce.uniqueResult(); //查询id的最大值
//ce.setProjection(Projections.max("id"));
//Integer count = (Integer)ce.uniqueResult(); System.out.println(count);
tx.commit();
session.close();
} /**
* 投影查询
*/
@Test
public void test6(){
Session session = HibernateUtil.openSession();
Transaction tx = session.beginTransaction();
Criteria ce = session.createCriteria(Order.class);
//投影操作
ProjectionList pList = Projections.projectionList();
pList.add(Property.forName("orderno"));
pList.add(Property.forName("productName"));
ce.setProjection(pList);
List<Object[]> list = ce.list();
for (Object[] objects : list) {
for (Object object : objects) {
System.out.print(object+"\t");
}
System.out.println();
} tx.commit();
session.close();
}
}
三. 本地SQL查询
1. Hibernate使用SQL语句介绍
本地sql查询可以直接执行 SQL 语句
5.2以后推荐使用
createNativeQuery5.2之前使用
createSQLQuery
2. Hibernate使用SQL语句
/**
* 演示本地 SQL 的查询
*/
public class SQLTest {
/**
* 5.2开始支持
*/
@Test
public void test1() {
Session session = HibernateUtil.openSession();
Transaction tx = session.beginTransaction();
NativeQuery<Order> sqlQuery = session.createNativeQuery("select * from t_order", Order.class);
List<Order> list = sqlQuery.list();
for (Order order : list) {
System.out.println(order);
}
tx.commit();
session.close();
} /**
* 5.2之前的用法
* 以JavaBean对象封装
*/
@Test
public void test2() {
Session session = HibernateUtil.openSession();
Transaction tx = session.beginTransaction();
SQLQuery sqlQuery = session.createSQLQuery("select * from t_order");
//封装成Order对像
sqlQuery.addEntity(Order.class);
List<Order> list = sqlQuery.list();
for (Order order : list) {
System.out.println(order);
}
tx.commit();
session.close();
} /**
* 5.2之前的用法
* 以对象数组封装
*/
@Test
public void test3() {
Session session = HibernateUtil.openSession();
Transaction tx = session.beginTransaction();
SQLQuery sqlQuery = session.createSQLQuery("select * from t_order");
List<Object[]> list = sqlQuery.list();
for(Object[] order : list) {
for(Object column : order) {
System.out.print(column);
System.out.print(" ");
}
System.out.println();
}
tx.commit();
session.close();
}
}
四. 延迟加载策略
延迟加载是为了减少程序和数据库的访问次数，提高程序的执行性能。
延迟加载的执行机制：
1）在查询一个对象的时候，不会到数据库查询对象的属性或者其关联的数据
2）在需要使用到对象的属性或关联数据的才会去查询数据库！
按需加载！
1. 类级别的(属性)延迟加载
public class LazyLoadingTest {
/**
* 类级别 延迟加载
*/
@Test
public void test1(){
Session session = HibernateUtil.openSession();
Transaction tx = session.beginTransaction();
//get()：get方法不支持类级别的延迟加载
/*
Customer cust = session.get(Customer.class, 1);//debug：此行查询了数据库
System.out.println(cust.getName());
*/
//load()：load方法支持类级别的延迟加载
Customer cust = session.load(Customer.class, 1);//debug：此行没有查询数据库
System.out.println(cust.getName());//debug：此行查询了数据库
tx.commit();
session.close();
}
}
结论：
load()：只有 load 方法才支持类级别的延迟加载
get()：get 方法不支持类级别的延迟加载
使用 load() 方法的默认延迟加载策略是延迟加载，可以在配置文件中修改延迟加载策略
<class name="Customer" table="t_customer" lazy="false">
2. 关联级别的
注意: 测试前先删除前面配置的lazy = "false"
以一对多为例
1）一方： <set/>
测试：
/**
* 关联级别 延迟加载（一方：<set/>）
* 修改一对多的延迟加载配置：<set name="orders" inverse="true" lazy="false">
*/
@Test
public void test2(){ Session session = HibernateUtil.openSession();
Transaction tx = session.beginTransaction(); Customer cust = session.get(Customer.class, 1L);
//关联订单
System.out.println(cust.getOrders().size()); //延迟加载的 tx.commit();
session.close(); }
结论：
类级别默认使用延迟加载策略，如果不想使用延迟加载策略，那么可以在配置文件中修改延迟加载策略：Customer.hbm.xml
<set name="orders" cascade="all" inverse="true" lazy="false">
多方 <many-to-one/>
测试:
/**
* 关联级别 延迟加载（多对一：<many-to-one/>）
* 修改多对一延迟加载配置：<many-to-one name="customer" class="Customer" column="customer_id" cascade="all" lazy="false"/>
*/
@Test
public void test3(){ Session session = HibernateUtil.openSession();
Transaction tx = session.beginTransaction(); Order order = session.get(Order.class, 1L);
System.out.println(order.getCustomer().getName()); // 延迟加载 tx.commit();
session.close();
}
结论：
类级别默认使用延迟加载策略，如果不想使用延迟加载策略，那么可以在配置文件中修改延迟加载策略：Order.hbm.xml
<many-to-one name="customer" class="Customer" column="customer_id" cascade="all" lazy="false"/>
五. 抓取策略
抓取策略，是为了改变 SQL 语句查询的方式，从而提高 SQL 语句查询的效率（优 化 SQL 语句）
可以设置以下三个值：
fetch="select(默认值)|join|subselect"
1. 查询一方单条记录:<set/>
在Customer.hbm.xml中配置 fetch="select" 会执行两条sql
<set name="orders" cascade="all" inverse="true" fetch="select">
配置 fetch="join" 会执行一条左外连接的sql语句。
注意：如果配置了join，那么延迟加载就会失效！
<set name="orders" cascade="all" inverse="true" fetch="join">
测试
public class FetchingStrategyTest {
/**
* 一方：<set/>
* fetch="select" : 默认情况，执行两条sql语句
* fetch="join"： 把两条sql合并成左外连接查询（效率更高）
* 注意：如果配置了join，那么延迟加载就会失效！
*/
@Test
public void test1(){
Session session = HibernateUtil.openSession();
Transaction tx = session.beginTransaction();
Customer cust = session.get(Customer.class, 1L);
System.out.println(cust.getOrders());
tx.commit();
session.close();
}
}
2. 查询一方多条记录: <set/>
此时无论设置 fetch="select" 还是 fetch="join" ，都会执行多条sql语句（n+1）
可以设置 fetch="subselect" ，会执行一条带有子查询的sql语句：
<set name="orders" cascade="all" inverse="true" fetch="subselect">
测试
/**
* 一方：<set/>
* 需求：在查询多个一方（客户列表）的数据，关联查询多方（订单）的数据
* 如果fetch的配置是select或join的时候，一共发出n+1条sql语句
* fetch="subselect"： 使用子查询进行关联查询
*/
@Test
public void test2(){ Session session = HibernateUtil.openSession();
Transaction tx = session.beginTransaction(); Query<Customer> query = session.createQuery("from Customer", Customer.class);
List<Customer> list = query.list();
for (Customer customer : list) {
System.out.println(customer.getOrders().size());
} tx.commit();
session.close(); }
3. 查询多方的记录: <many-to-one/>
Order.hbm.xml中配置 fetch="select" 会执行两条sql
<many-to-one name="customer" class="Customer" column="customer_id" cascade="all" fetch="select"/>
配置 fetch="join" 会执行一条左外连接的sql语句。
注意：如果配置了join，那么延迟加载就会失效！
<many-to-one name="customer" class="Customer" column="customer_id" cascade="all" fetch="join"/>
测试:
/**
* 多方：<many-to-one/>
* fetch="select" : 默认情况，执行两条sql语句（支持延迟加载）
* fetch="join"： 把两条sql合并成左外连接查询（效率更高）
* 注意：如果配置了join，那么延迟加载就会失效！
*/
@Test
public void test3(){ Session session = HibernateUtil.openSession();
Transaction tx = session.beginTransaction(); Order order = session.get(Order.class, 1);
System.out.println(order.getCustomer()); tx.commit();
session.close(); }
Hibernate优化策略
Hibernate二级缓存
Hibernate查询缓存
Hibernate整合c3p0
六. 整合连接池
1. 导入 c3p0 的整合相关包
在hibernate解压目录下 lib/optional/c3p0 中可以找到整合相关的包
如果maven项目,pom配置
<dependency>
<groupId>org.hibernate</groupId>
<artifactId>hibernate-c3p0</artifactId>
<version>5.2.10.Final</version>
</dependency>
2. 在Hibernate.cfg.xml添加整合配置
在连接数据库参数的后面添加:
<!-- 整合c3p0：必要 -->
<property name="hibernate.connection.provider_class">org.hibernate.c3p0.internal.C3P0ConnectionProvider</property>
<!-- c3p0详细配置：可选 -->
<property name="c3p0.min_size">10</property>
<property name="c3p0.max_size">20</property>
3. 测试是否启动连接池
public class PoolTest {
/**
* 演示连接池的整合
*/
@Test
public void test1(){
Session session = HibernateUtil.openSession();
session.doWork(new Work(){
@Override
public void execute(Connection connection) throws SQLException {
System.out.println(connection);
}
});
session.close();
}
}
七.二级缓存
Hibernate 的一级缓存：就是 Session 对象的缓存，而 Session 对象在每次操作之 后都会关闭，那么一级缓存就丢失！
结论 ：一级缓存只用于一次业务操作内的缓存。
Hibernate 的二级缓存：就是 SessionFactory 的缓存，二级缓存和 SessionFactory 对象的生命周期是一致的，SessionFactory 不消耗，那么二级缓存的数据就不会 丢失！
结论：二级缓存可以用于多次业务操作的缓存。
多个Session 可以共同使用二级缓存
注意的问题：
1）Hibernate 一级缓存默认是开启的，而且无法关闭。
2）Hibernate 二级缓存默认是关闭的，如果使用需要开启，而且需要引入第三 方的缓存工具，例如 EhCache 等。
1. 添加二级缓存需要实现jar包
jar包位置: hibernate解压目录下 lib/optional/ehcache下找到相关包!
maven项目,pom文件添加
<dependency>
<groupId>org.hibernate</groupId>
<artifactId>hibernate-ehcache</artifactId>
<version>5.2.10.Final</version>
</dependency>
2. 配置二级缓存
在hibernate.cfg.xml中配置以下节点:
1.property 节点 要放在 mapping 节点的上方
<!-- 开启 Hibernate 的二级缓存 -->
<property name="hibernate.cache.use_second_level_cache">true</property>
<!-- 引入 EhCache 的工具 -->
<property name="hibernate.cache.region.factory_class">
org.hibernate.cache.ehcache.EhCacheRegionFactory
</property>
2.class-cache 节点 要放在 mapping 节点的下方
<!-- 需要缓存哪个类 -->
<class-cache usage="read-only" class="pojo.Customer"/>
3. 测试
使用二级缓存只打印1条sql，不使用二级缓存会打印2条sql
public class CacheLevelTwoTest {
/**
* 演示二级缓存
* hibernate查询策略，如果二级缓存开启，则先到二级缓存中查询，如果查不到，则到session中查询，如果查
* 不到，则到数据库中查询，然后查询结果，放入一级缓存和二级缓存中，以备下次查询使用
*/
@Test
public void test1(){
Session session = HibernateUtil.openSession();
//第1次操作
Customer cust = session.get(Customer.class, 1L);
System.out.println(cust.getName());
//关闭session
session.close();
//第2次操作
session = HibernateUtil.openSession();
cust = session.get(Customer.class, 1L);
System.out.println(cust.getName());
session.close();
}
}
Hibernate查询以及优化策略04的更多相关文章
- 【转】Mysql查询语句优化策略
1.对查询进行优化,应尽量避免全表扫描,首先应考虑在 where 及 order by 涉及的列上建立索引. 2.应尽量避免在 where 子句中使用!=或<>操作符,否则将引擎放弃使用索 ...
- SQl语句查询性能优化
[摘要]本文从DBMS的查询优化器对SQL查询语句进行性能优化的角度出发,结合数据库理论,从查询表达式及其多种查询条件组合对数据库查询性能优化进行分析,总结出多种提高数据库查询性能优化策略,介绍索引的 ...
- Hibernate多表查询、查询优化策略（四）
多表HQL private static void innerJoin(){ //sql内连接 隐式内连接 select * from A,B where b.aid = a.id // 显示内连接 ...
- Spring/Hibernate 应用性能优化的7种方法
对于大多数典型的 Spring/Hibernate 企业应用而言,其性能表现几乎完全依赖于持久层的性能.此篇文章中将介绍如何确认应用是否受数据库约束,同时介绍七种常用的提高应用性能的速成法.本文系 O ...
- PHP中的数据库一、MySQL优化策略综述
前些天看到一篇文章说到PHP的瓶颈很多情况下不在PHP自身,而在于数据库.我们都知道,PHP开发中,数据的增删改查是核心.为了提升PHP的运行效率,程序员不光需要写出逻辑清晰,效率很高的代码,还要能对 ...
- Hibernate缓存原理与策略
Hibernate缓存原理: 对于Hibernate这类ORM而言,缓存显的尤为重要,它是持久层性能提升的关键.简单来讲Hibernate就是对JDBC进行封装,以实现内部状态的管理,OR关系的映射等 ...
- 高性能MySQL笔记 第6章 查询性能优化
6.1 为什么查询速度会慢 查询的生命周期大致可按照顺序来看:从客户端,到服务器,然后在服务器上进行解析,生成执行计划,执行,并返回结果给客户端.其中“执行”可以认为是整个生命周期中最重要的阶段. ...
- Hibernate缓存原理与策略 Hibernate缓存原理:
Hibernate缓存原理: 对于Hibernate这类ORM而言,缓存显的尤为重要,它是持久层性能提升的关键.简单来讲Hibernate就是对JDBC进行封装,以实现内部状态的管理,OR关系的映射等 ...
- mysql笔记03 查询性能优化
查询性能优化 1. 为什么查询速度会慢? 1). 如果把查询看作是一个任务,那么它由一系列子任务组成,每个子任务都会消耗一定的时间.如果要优化查询,实际上要优化其子任务,要么消除其中一些子任务,要么减 ...
随机推荐
- DSL 系列（2） - 插件的论述与实现
前言 本文主要探讨基于 DSL(domain specific language) 之上的插件设计,他们是领域的附属,为领域提供额外的服务,但领域不依赖于他们. 1. 论述 领域应当尽可能地去专注他的 ...
- 使用Comparable接口自定义排序
Employee: package textq; /** * 调用接口Comparable排序 * @author Administrator * */ public class Employee i ...
- urllib库
python内置的最基本的HTTP请求库,有以下四个模块: urllib.request 请求模块 urllib.error 异常处理模块 urllib.parse url解析模块 urllib.ro ...
- python的UnboundLocalError： local variable 'xxx' referenced b
一.意思: 本地变量xxx引用前没定义. 二.错误原因 在于python没有变量的声明 , 所以它通过一个简单的规则找出变量的范围 :如果有一个函数内部的变量赋值 ,该变量被认为是本地的,所以 ...
- Memcache之安装篇
本篇文章会介绍memcache在Windows和Linux下的具体安装过程,详细的记录其中的流程内容,帮助小伙伴们快速的搭建起memcache服务,废话少说,直接上!!! Windows: Memca ...
- node-sass下载失败 关于webpack
安装node-sass提示没有vendor目录的解决办法在node-sass目录下面新建一个vendor的空目录,然后运行npm/cnpm rebuild node-sass --save-dev即可 ...
- VS如何在调试时进入到dll文件
背景: 项目A:用C#写的一个类库文件 项目B:引用项目A的dll文件,完成编码,也是C#编写的. 需求:怎么能在调试的时候,调试断点能够从项目B中进入项目A中的代码. 解决办法就是: 假设,项 ...
- [转帖]Linux 下如何知道是否有人在使坏？
Linux 下如何知道是否有人在使坏? 学到了两个最简单的命令 usermod -L username 锁定账户 passwd -s username 查看用户状态. 自己linux 知道的还是少 需 ...
- js尾递归函数
普通递归: function fac(n) { if (n === 1) return 1; return n * fac(n - 1); } fac(5) // 120 这是个阶乘.但是占用内存,因 ...
- html5调用手机摄像头（图片可多选 限pc）
html5自带的 input file=”” ,纯html5,并且不涉及到js ,就可以实现.代码如下: <input type="file" accept="im ...