Day41-Hibernate04 --检索方式及增强，离线条件查询，hql多表查询，抓取策略

最新推荐文章于 2020-12-25 17:45:49 发布
最新推荐文章于 2020-12-25 17:45:49 发布
阅读量586 收藏 1
点赞数
分类专栏： java学习随记 文章标签： hibernate hql 面向对象
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jjizh/article/details/76451536
版权
这篇博客介绍了Hibernate的多种检索方式，包括HQL、QBC（Query By Criteria）以及DetachedCriteria的离线条件查询。强调了QBC作为最优选择，特别是DetachedCriteria在复杂查询条件时的优势。还讨论了Hibernate的查询优化，如抓取策略和延迟加载，以及如何通过设置fetch和lazy属性来调整关联对象的加载行为，以提高性能。
摘要由CSDN通过智能技术生成

Hibernate的检索方式：

*      对象图导航检索方式 -- 对象导航查询
*      OID检索方式 -- 用session的get（）/load（）方法，就是利用id查询
*      HQL检索方式 -- 面向对象的查询语言
*      QBC检索方式
*      SQL检索方式

最优选择QBC（Query By Criteria）查询，特别是离线查询对象很好用；最后选择SQLQuery；

HQL检索方式：

命名查询：
好处：不用特别记住参数是第几个，直接用命名的方式代替；对于参数很多的情况很好用

      @Test
      public void test011() {
           Session session = HibernateUtils.openSession();
           Transaction transaction = session.beginTransaction();

           Query query = session.createQuery("from Employee  where ename = :ename");
           query.setString("ename", "市场1号");
           List<Employee> list = query.list();
           for (Employee employee : list) {
                 System.out.println(employee);
           }
           // 释放资源
           transaction.commit();
           session.close();
      }

      @Test
      public void test011() {
           Session session = HibernateUtils.openSession();
           Transaction transaction = session.beginTransaction();

           Query query = session.createQuery("from Employee where ename like :ename and eid >:eid");
           query.setString("ename", "%市场%");
           query.setInteger("eid", 5);
           List<Employee> list = query.list();
           for (Employee employee : list) {
                 System.out.println(employee);
           }
           // 释放资源
           transaction.commit();
           session.close();
      }

投影检索：
其实就是根据不同的字段来查询，如果查询的是多个字段，就会将每条查询结果封装成为一个数组。

      @Test//投影查询
      public void test013() {
           Session session = HibernateUtils.openSession();
           Transaction transaction = session.beginTransaction();
           Query query = session.createQuery("select eid,ename from Employee ");
           List<Object[]> list = query.list();
           for (Object[] object : list) {
                 System.out.println(Arrays.toString(object));
           }
           // 释放资源
           transaction.commit();
           session.close();
      }

投影构造查询：
这种方法需要创建对应参数的构造函数，同时也不要忘记了保留无参数的构造函数，这样只封装了需要的参数到持久化类的对象中去。

      @Test//投影构造查询
      public void test014() {
           Session session = HibernateUtils.openSession();
           Transaction transaction = session.beginTransaction();
           Query query = session.createQuery("select new Employee(eid,ename) from Employee ");
           List<Employee> list = query.list();
           for (Employee employee : list) {
                 System.out.println(employee);
           }
           // 释放资源
           transaction.commit();
           session.close();
      }

QBC检索方式增强：Query By Criteria

QBC是一种完全面向对象的查询语言，所有使用的方法类都是对象

1）使用Order类进行排序查询
使用order类，通过其order的静态方法产生Order对象（排序对象）
2）api 

*      static Order desc（String propertyName）Order类的静态方法，返回Order的实例对象，按照propertyName（持久化类的属性名）进行降序排列。
*      static Order asc（String propertyName）
*      criteria.addOrder（Order order），Criteria对象，增加排序对象

      @Test//Order类，按照单个字段进行排序
      public void test015() {
           Session session = HibernateUtils.openSession();
           Transaction transaction = session.beginTransaction();

           Criteria criteria = session.createCriteria(Employee.class);
           Order desc = Order.desc("eid");
           criteria.addOrder(desc);

           List list = criteria.list();
           for (Object object : list) {
                 System.out.println(object);
           }

           // 释放资源
           transaction.commit();
           session.close();
      }


      @Test//Order类,按照多个字段进行排序
      public void test016() {
           Session session = HibernateUtils.openSession();
           Transaction transaction = session.beginTransaction();

           Criteria criteria = session.createCriteria(Employee.class);
           Order desc = Order.desc("eid");
           Order asc = Order.asc("department");
           //先加入哪一个排序条件就按照哪一个排序条件进行排序，如果相等的情况才会按照第二个排序条件进行排序
           criteria.addOrder(desc);
           criteria.addOrder(asc);

           List list = criteria.list();
           for (Object object : list) {
                 System.out.println(object);
           }

           // 释放资源
           transaction.commit();
           session.close();
      }

2）Projection类
Projection可以完成分组统计 、 获取最大值 、 获取最小值 、 获取记录条数
细节：分组和统计、以及得出最大最小值、符合条件的记录数都用Projection

使用Projection，Projections和ProjectList类

*      Projection：对象，分组统计对象，对于每个分组或者统计条件，创建一个Projection对象
*      Projections：工具类，用于获得Projection实例对象
*      ProjectionList：分组统计对象的集合，用于保存多个分组的统计对象

api：
a) Projections工具类的静态方法，返回值是一个Projection实例对象
Projections.groupProperty（String propertyName）

 b）Projections.max(String propertyName)  //可以用于数据表中某个字段的最大最小值
      Projections.avg(String propertyName)
      Projections.rouCount(String propertyName)
      Projections.count(String propertyName)
      Projections.min(String propertyName)
      Projections.countDistinct(String propertyName)

 c)criteria.setProjection(Projection projection)：
      --Criteria对象，设置分组统计对象。

 d) static ProjectionList projectionList():

–获取projection集合对象，因Criteria对象，只能保存一个Projection对象，在进行分组统计的联合使用时，必定存在二个及以上的Projection对象，所以，需要ProjectionList来保存。

案例：

     @Test//查询id最大的员工
      public void test017() {
           Session session = HibernateUtils.openSession();
           Transaction transaction = session.beginTransaction();

           Criteria criteria = session.createCriteria(Employee.class);

           Projection projection = Projections.max("eid");
           criteria.setProjection(projection);

           Object uniqueResult = criteria.uniqueResult();
           System.out.println(uniqueResult);

           // 释放资源
           transaction.commit();
           session.close();
      }

      @Test//查询记录条数
      public void test017() {
           Session session = HibernateUtils.openSession();
           Transaction transaction = session.beginTransaction();

           Criteria criteria = session.createCriteria(Employee.class);

           Projection projection = Projections.count("eid");
           criteria.setProjection(projection);

           Object uniqueResult = criteria.uniqueResult();
           System.out.println(uniqueResult);

           // 释放资源
           transaction.commit();
           session.close();
      }

      @Test//按性别分类和按照分类进行查询各类的记录条数，就是分组统计：先进行分组，然后进行统计
      public void test018() {
           Session session = HibernateUtils.openSession();
           Transaction transaction = session.beginTransaction();

           Criteria criteria = session.createCriteria(Employee.class);
           Projection projection1 = Projections.groupProperty("sex");
           Projection projection2 = Projections.count("id");
           ProjectionList projectionList = Projections.projectionList();
           //为什么用ProjectionList，因为setProjection（）方法底层只能够加入一个条件
           projectionList.add(projection1);
           projectionList.add(projection2);
           criteria.setProjection(projectionList);

           List<Object[]> list = criteria.list();
           for (Object[] object : list) {
                 System.out.println(Arrays.toString(object));
           }

           // 释放资源
           transaction.commit();
           session.close();
      }

离线条件查询 DetachedCriteria – QBC的皇冠

  1. DetachedCriteria的定义

    • 翻译成离线条件查询，可以脱离Session使用，即无需依靠Session就可以创建。
    • 普通Criteria对象，必须有Session对象创建，即先有Session对象，后有Criteria对象。因为session中才有这数据库的连接对象，才能够操作数据库

  2. 常见API介绍
    a. static DetachedCriteria forClass(Class clazz): // DetechedCriteria的静态方法，用于创建DetechedCriteria实例对象，clazz指需要查询的持久化类的字节码对象。

    b. 增加查询条件，排序，分组统计，和普通的Criteria完全一样。

    c. Criteria getExecutableCriteria(Session session): //成员方法，通过session对象，获得普通的Criteria对象，完成查询操作。


      @Test//离线条件查询
      public void test020() {
           //创建离线对象
           DetachedCriteria dc = DetachedCriteria.forClass(Employee.class);
           //设定查询条件
           dc.add(Restrictions.gt("eid", 5));

           //获取session
           Session session = HibernateUtils.openSession();
           Transaction transaction = session.beginTransaction();

           //离线查询对象通过session，可以获得可以使用的criteria，相当于复活了
           Criteria criteria = dc.getExecutableCriteria(session);
           List list = criteria.list();
           for (Object object : list) {
                 System.out.println(object);
           }
           transaction.commit();
           session.close();
      }

离线条件查询的价值：
例如京东的查询筛选，筛选条件十分多，而且可能是多选就可以采取离线条件查询，先把条件一个一个的加入到离线对象中去，然后复活对象进行查询。
这里写图片描述
这里写图片描述

HQL的多表查询（了解）
多表查询只能够使用HQL语言查询

      @Test
      public void test01() {
           Session session = HibernateUtils.openSession();
           Transaction transaction = session.beginTransaction();

           Query query = session.createQuery("from Employee e,Department d where e.department = d.did ");
           //注意，在HQL语言中，判定两个字段是不是相等用的就是其id判断的
           List<Object[]> list = query.list();
           //System.out.println(list.size());
           for (Object[] object : list) {
                 System.out.println(Arrays.toString(object));
           }

           // 释放资源
           transaction.commit();
           session.close();
      }

      @Test //显式内连接
      public void test02() {
           Session session = HibernateUtils.openSession();
           Transaction transaction = session.beginTransaction();

           Query query = session.createQuery("from Employee e inner join Department d on e.department = d.did ");
           List<Object[]> list = query.list();
           //System.out.println(list.size());
           for (Object[] object : list) {
                 System.out.println(Arrays.toString(object));
           }

           // 释放资源
           transaction.commit();
           session.close();
      }

迫切内连接：

迫切内联接：查询到的结果，封装成一个对象，其他的数据，封装到这个对象的关联对象。
使用迫切内连接的时候一定要加上去重的条件

迫切内联接和普通内联接的区别：
a. fetch：表示：迫切
b. 普通内联接：查询到的结果，会封装成2个对象。
c. 迫切内联接：查询到的结果，封装成一个对象，其他的数据，封装到这个对象的关联对象。
* 因为数据存在重复，需要去重：distinct
* 标准写法：select distinct x from Department x inner join fetch x.employees

      @Test //迫切内连接
      public void test03() {
           Session session = HibernateUtils.openSession();
           Transaction transaction = session.beginTransaction();

           Query query = session.createQuery("select distinct d from Department d inner join fetch d.employees");
           List<Department> list = query.list();
           for (Department object : list) {
                 System.out.println(object);
           }

           // 释放资源
           transaction.commit();
           session.close();
      }

hibernate的查询优化–抓取策略 和 延迟加载

  1. 原因：hibernate的关联查询（级联），非常优美。但严重的影响性能。为了提高性能，hibernate增加了补丁，即抓取策略。

  2. 抓取策略：只针对如何获取（查询）关联对象进行优化。

    • 项目的实际需求中，90%以上的sql操作–查询。所以，数据库专门创建了查询神器：索引。
      索引的好处：提高查询的效率；缺陷：降低增加、删除、修改的效率。

  3. 抓取策略，需要配合延迟加载一起使用。

  4. 抓取策略：注重发送的sql语句形式。
    延迟加载注重：什么时候，发送sql语句。

了解抓取策略：
1. 抓取策略是什么
a. 简单而言：hibernate如何获取关联对象的方法。
b. 是hibernate提升性能的一种方法。
c. 使用抓取策略的时候，延迟加载也会影响查询性能。所以，抓取策略和延迟加载，是配合使用。

  1. 为什么学习抓取策略
    • 项目开发中，查询无处不在。但hibernate本身的查询效率不好。加上hibernate有关联机制（1对多关系，多对多关系），什么时候获取关联对象，如何获取关联对象，对查询性能的影响很大。所以，hibernate通过抓取策略，来对关联对象的查询，进行优化。

hibernate的延迟加载：延迟加载可以针对类和关联对象

  1. 延迟加载定义

    • 延迟加载，也成为懒加载，只有真正需要数据的时候，才真正执行数据加载操作（发送sql查询语句）。

  2. 延迟加载的分类
    a. 类级别的延迟加载
    (1) 查询某个对象时，是否延迟，标签上配置lazy属性，默认值是：true,默认延迟加载。
    b. 关联级别的延迟加载。
    (1) 查询一个对象的关联对象时，是否延迟。在或上配置延迟。
    (2) hibernate关联对象默认采用延迟加载。可以避免一些不必要的性能开销

关联对象的抓取策略和延迟加载 – 批量抓取

一）set标签 中配置fetch抓取策略和lazy延迟加载
1）set标签 中配置fetch抓取策略和lazy延迟加载
a. fetch的取值：抓取策略
(1) select.默认值，发送普通的select语句，用到什么查什么
(2) join：发送迫切左外联接去查询。一次性全部查询完
(3) subselect。发送一条子查询语句查询其关联对象.(查询多个对象，才能体现)，配置了之后，要查询多个关联对象的时候，只发送一条sql语句将所有关联对象查询出来。

 b. lazy的取值：
    (1) true。默认值，采用延迟加载
    (2) false.不采用延迟加载
    (3) extra. 极其懒惰的

2）理解fetch和lazy的取值
a. fetch，配置抓取策略。不同的配置，在查询关联对象时，发送的SQL语句不同。
b. lazy，配置延迟加载。不同的配置，在查询关联对象时，发送SQL语句的时间不同。（立即发送，还是延迟发送）

3）详解
(1) fetch和lazy,关注都是查询关联对象。
(2) fetch=”join”，发送迫切左外连接，把当前对象及其关联对象，一条SQL语句，全部获取。无需再次发送SQL语句，进行关联对象查询，也就无所谓延迟加载的设定（lazy失效）
(3) fetch=”subselect”,需要查询多个对象，才能体现。
(4) lazy=”extra”,意味着“极其懒惰的”，

二）many-to-one上的fetch和lazy
1. 验证的场景
* 查询某个员工，及该员工所在部门的名称

  1. many-to-one标签
    a. fetch的取值：
    (1) select.默认值，发送普通的select语句
    (2) join：发送迫切左外联接去查询
    b. lazy的取值：
    (1) proxy。默认值，是否延迟取决于一的一方类上lazy属性
    (2) false.不采用延迟加载
    (3) no-proxy:不用研究

三）关联对象的抓取策略：批量抓取
1. 感受批量抓取
a. 场景1：查询所有部门，并查询每个部门的所有员工的名字
* 在set上配置:batch-size=”3”

b. 场景2：查询所有员工，并查询其对应部门的名称
    * batch-size必须配置在一的一方的<class>标签上

案例：
理解配置subselect策略的时候的现象：

      @Test
      public void test02(){
           Session session = HibernateUtils.openSession();
           Transaction transaction = session.beginTransaction();

           Criteria criteria = session.createCriteria(Department.class);
           List<Department> list = criteria.list();
           for (Department object : list) {
                 System.out.println(object.toString());
                 System.out.println(object.getEmployees().size());
           }

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

配置为select抓取策略的时候的sql语句：
有多少条记录，执行多少条sql语句进行查询数据库

Hibernate:
    select
        this_.did as did1_0_0_,
        this_.dname as dname2_0_0_
    from
        department this_
Hibernate:
    select
        employees0_.e_did as e_did4_1_0_,
        employees0_.eid as eid1_1_0_,
        employees0_.eid as eid1_1_1_,
        employees0_.ename as ename2_1_1_,
        employees0_.sex as sex3_1_1_,
        employees0_.e_did as e_did4_1_1_
    from
        employee employees0_
    where
        employees0_.e_did=?
Hibernate:
    select
        employees0_.e_did as e_did4_1_0_,
        employees0_.eid as eid1_1_0_,
        employees0_.eid as eid1_1_1_,
        employees0_.ename as ename2_1_1_,
        employees0_.sex as sex3_1_1_,
        employees0_.e_did as e_did4_1_1_
    from
        employee employees0_
    where
        employees0_.e_did=?
Hibernate:
    select
        employees0_.e_did as e_did4_1_0_,
        employees0_.eid as eid1_1_0_,
        employees0_.eid as eid1_1_1_,
        employees0_.ename as ename2_1_1_,
        employees0_.sex as sex3_1_1_,
        employees0_.e_did as e_did4_1_1_
    from
        employee employees0_
    where
        employees0_.e_did=?
Hibernate:
    select
        employees0_.e_did as e_did4_1_0_,
        employees0_.eid as eid1_1_0_,
        employees0_.eid as eid1_1_1_,
        employees0_.ename as ename2_1_1_,
        employees0_.sex as sex3_1_1_,
        employees0_.e_did as e_did4_1_1_
    from
        employee employees0_
    where
        employees0_.e_did=?

配置为subselect抓取策略时候的语句：

Hibernate:
    select
        this_.did as did1_0_0_,
        this_.dname as dname2_0_0_
    from
        department this_
Hibernate:
    select
        employees0_.e_did as e_did4_1_1_,
        employees0_.eid as eid1_1_1_,
        employees0_.eid as eid1_1_0_,
        employees0_.ename as ename2_1_0_,
        employees0_.sex as sex3_1_0_,
        employees0_.e_did as e_did4_1_0_
    from
        employee employees0_
    where
        employees0_.e_did in (
            select
                this_.did
            from
                department this_
        )
jjizh
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
hibernate 离线条件查询
Java 爱好者
07-19 1227
条件查询一般是通过以下三个类完成的：              1、Criteria:代表一次查询              2、Criterion：代表一个查询条件              3、Restriction：代表查询条件的工具类           执行条件查询的步骤如下：              1、获得Hibernate的Session对象             
QBC查询、离线条件查询（DetachedCriteric）和分页查询模版
weixin_30257433的博客
07-25 84
一、QBC检索步骤 　　QBC检索步骤： 　　1.调用Session的createCriteria()方法创建一个Criteria对象。 　　2.设定查询条件。Expression类提供了一系列用于设定查询条件的静态方法， 　　这些静态方法都返回Criterion实例，每个Criterion实例代表一个查询条件。 　　Criteria的add()方法用于加入查询条件。 　　3...
多个值的离线查询
..
10-14 126
/** * 名称查重 * @param qrybo 查重条件 * @return 如果重复的话，则显示所有重复的记录(为SimpleName中的内容) * @throws SysException */ public List checkDoubleName(NameQueryBO qrybo) throws SysException{ DetachedC...
Hibernate学习笔记四：hql查询、sql多表查询再理解、离线查询、lazy加载机制、关联级别查询
公子&小白的博客
04-09 231
文章目录1. Hibernate学习笔记四：hql语法学习1.1. hql基本语法1.2. sql多表查询1.3. hql多表查询1.4. Criteria语法学习1.5. 离线查询1.6. lazy延迟加载机制1.7. 关联级别查询 1. Hibernate学习笔记四：hql语法学习 1.1. hql基本语法 查询所有 String hql = " from cn.zhangsan.dom...
Day28-Linux入门01
jjizh的博客
07-13 686
Linux
day36 04-Hibernate检索方式：多表连接查询
04-26
标题中的“day36 04-Hibernate检索方式：多表连接查询”表明这是一个关于Hibernate框架的教程，重点讲解如何在Hibernate中进行多表连接查询。在这个主题中，我们将深入探讨Hibernate的ORM（对象关系映射）机制以及...
day36-hibernate检索和优化 02-Hibernate检索方式：简单查询及别名查询
04-26
本教程将深入探讨"day36-hibernate检索和优化 02-Hibernate检索方式：简单查询及别名查询"的主题，通过源码分析和实际工具的应用，来提升数据库查询的效率。 首先，我们了解Hibernate的检索方式。在Hibernate中，...
Hibernate hql查询代码实例
08-28
Hibernate HQL 查询代码实例 Hibernate 是一个流行的基于 Java 的持久层框架，它提供了一个名为 Hibernate Query Language（HQL）的查询语言，用于查询和操作数据库中的数据。HQL 是完全面向对象的查询语句，具有...
day36 07-Hibernate抓取策略：many-to-one上的抓取策略
04-26
在提供的文件"hibernate_day03"中，可能包含相关的代码示例和更深入的解释，通过阅读和实践这些内容，你可以更好地掌握Hibernate的抓取策略，特别是对于"many-to-one"关系的应用。记住，理论知识固然重要，但实践...
bookmark20160330
热门推荐
dingohaha60的博客
03-30 4万+
It will be read and overwritten.      DO NOT EDIT! --> Bookmarks Bookmarks     书签栏             百度一下，你就知道         20160311                     redis - 必应             REDIS 3.0.7 下载
JAVA8新特性
专注于后端开发，时常接触大数据 、人工智能等
11-28 484
一、Java 8 Lambda表达式 Lambda表达式，也可称为闭包，它是推动Java 8发布的最重要新特性。 Lambda允许把函数作为一个方法的参数（函数作为参数传递进方法中）。 使用Lambda表达式可以使代码变的更加简洁紧凑。 1.1语法 lambda表达式的语法格式如下： (parameters)->expression或(parameter...
Hibernate的几种查询方式-HQL,QBC,QBE,离线查询,复合查询,分页查询
Ijse技术博客
01-23 1万+
HQL查询方式 这一种我最常用，也是最喜欢用的，因为它写起来灵活直观，而且与所熟悉的SQL的语法差不太多。条件查询、分页查询、连接查询、嵌套查询，写起来与SQL语法基本一致，唯一不同的就是把表名换成了类或者对象。其它的，包括一些查询函数（count(),sum()等）、查询条件的设定等，全都跟SQL语法一样。 示例： 1: Session session = SessionFactory.getCurrentSession(); 2: User user
Hibernate离线查询解说
fordushao的博客
11-01 3524
Hibernate离线查询解说使用离线查询原因：一般我们进行web开发都会碰到多条件查询。例如根据条件搜索。条件的多少 逻辑关系 是or 还是and等等。我们要根据这些条件来拼写查询语句。我们可以使用DetachedCriteria来构造查询条件就不必为了查询条件的变化而去频繁改动查询语句了。使用方法步骤 ：1.先创建一个DetachedCriteria对象：DetachedCriteria.for
使用HQL语句方式实现多表多条件组合模糊查询
C_____Lee的博客
05-02 3654
最近在做struts2+hibernate项目整合，其中有一个两表多条件组合模糊查询功能： 将页面查询条件封装为对象，传至后台处理： /*查询实例类/ package com.newer.bean; import java.util.Date;/** * 模糊查询对象实体类 * * @author Siglam Lee * */ public class SearchM
Hibernate检索方式：离线条件查询
y_dzaichirou的博客
12-27 1856
投影查询：就是只查询某几个属性的时候 如果是QBC的只想显示某几个属性，可以通过setProjection(),往list集合里添加属性。 在HQL查询语句中可以调用聚合函数 count() min() max() sum() avg() 报表查询就是使用聚合函数
Day27-基础加强（注解Annotation、动态代理）
jjizh的博客
07-13 470
注解Annotation注解概述：
Hibernate 查询与多表操作
~~~~~~~~~~~~
03-04 4002
Hibernate主键ID生成方式 数据库中表有主键、主键的唯一性决定了数据库表中记录唯一。缓存在Session中的数据即实例都有一个唯一的ID,ID映射了数据库中主键。那么ID如何产生呢？ 1、assigned:主键由外部程序负责生成，无需Hibernate参与。即当增加一个实体时，由程序设定它的ID值(手工分配值)
Java学习day19-异常
小苏(º﹃º )的博客
12-25 582
异常**今日目标**一. 什么是异常1.1.异常结构1.2.异常收集二.捕获异常1.try-catch2.try-catch-finally3.深入认识异常三.声明和抛出异常1.使用throws声明异常2.使用throw抛出异常四.自定义异常总结作业 今日目标 了解异常 捕获异常 自定义异常 一. 什么是异常 异常机制： ​ 异常机制是指当程序出现错误后，程序如何处理。具体来说，异常机制提供了程序退出的安全通道。当出现错误后，程序执行的流程发生改变，程序的控制权转移到异常处理器。 通俗地说：为了让程序继
Mac下用charles:http+https抓包笔记
屎壳郎情调-成长日记
12-31 2670
使用工具：charles下载地址：http://www.charlesproxy.com/latest-release/download.do（一下内容转载自：http://blog.csdn.net/jiangwei0910410003/article/details/41620363/）今天就来看一下Mac上如何进行抓包，之前有一篇文章介绍了使用Fidder进行抓包http://blog.cs...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值