• Hibernate检索策略与检索方式

    hibernate的Session在加载Java对象时，一般都会把鱼这个对象相关联的其他Java对象也都加载到缓存中，以方便程序的调用。但很多情况下，我们不需要加载太多无用的对象到缓存中，一来会占用大量的内存，二来会增加数据库的访问次数，使得程序的运行效率降低。为了合理的使用缓存，Hibernate提供了不同的检索策略来解决这些问题。

    作用域

          在说检索策略之前，先了解一下检索策略的作用域，它分为：类级别和关联级别。类级别的作用域在检索数据时，检索的数据只包含一个类对象，不涉及与该类关联的其他对象。关联级别的作用域检索的数据包含相关联的多个类的对象，例如，Customer对象与Orders对象存在关系，检索到一个Customer对象后，还会涉及与之关联的Orders对象。

    作用域对比

    检索策略

    Hibernate的检索策略分为三种，立即检索、延迟检索、左外连接检索。

    立即检索

         采用立即检索策略，会把被检索的对象，以及和这个对象关联的一对多对象都加载到缓存中。Session的get方法就使用的立即检索策略。这种策略的优点在于，频繁使用的对象会被加载到缓存中，程序调用很方便，也很及时。缺点就是，占用的内存过多，而且数据库访问的次数也会很频繁，效率低下。

    延迟检索

          采用延迟检索策略，就不会加载关联对象的内容。直到第一次调用关联对象时，才去加载关联对象。在不涉及关联类操作时，延迟检索策略只适用于Session的load方法。涉及关联类操作时，延迟检索策略也能够适用于get，list等操作。

          在类级别操作时， 延迟检索策略，只加载类的OID不加载类的其他属性，只用当第一次访问其他属性时，才回访问数据库去加载内容。（这里使用了CGLIB生成了类的代理类）
    在关联级别操作时，延迟检索策略，只加载类本身，不加载关联类，直到第一次调用关联对象时，才去加载关联对象。

          程序模式都是用延迟加载策略。如果需要指定使用延迟加载策略。在配置文件中设置<class>的lazy=true，<set>的lazy=true或extra（增强延迟）<many-to-one>的lazy=proxy和no-proxy。

          这种策略的优点在于，由程序决定加载哪些类和内容，而不必全部都加载，避免了内存的大量占用和数据库的频繁访问。缺点就是在Session关闭后，就不能访问关联类对象了。 需要确保Session一直处于打开状态，调用关联对象，最后在关闭Session对象。

    左外连接检索

           采用左外连接检索，能够使用Sql的外连接查询，将需要加载的关联对象加载在缓存中。<set>fetch设置为join，<many-to-one>的fetch设置为join。

           这种策略的优点在于，对应用程序完全透明，不管对象处于持久化状态，还是游离状态，应用程序都可以方便的从一个对象导航到与它关联的对象。使用了外连接，select语句数目少。缺点就是可能会加载应用程序不需要访问的对象，白白浪费许多内存空间。复杂的数据库表连接也会影响检索性能。

    三种策略运行机制

    检索方式

          Hibernate提供的检索方式为5种，分为导航对象图检索方式、OID检索方式、HQL检索方式、QBC检索方式、本地SQL检索方式。

    导航对象图检索方式

           利用类与类之间的关系来检索对象。譬如我们要查找一份订单，就可以由订单对象自动导航找到订单所属的客户对象。当然，前提是必须在对象-关系映射文件上配置了它们的多对一的关系。

    OID检索方式

           主要指用Session的get()和load()方法加载某条记录对应的对象。

    HQL检索方式

            HQL（Hibernate Query Language）是面向对象的查询语言，它和SQL查询语言有些相似。在Hibernate提供的各种检索方式中，HQL是使用最广的一种检索方式。它具有以下功能：

            在查询语句中设定各种查询条件。
            支持投影查询，即仅检索出对象的部分属性。
            支持分页查询。
            支持分组查询，允许使用group by和having关键字。
            提供内置聚集函数，如sum()、min()和max()。
            能够调用用户定义的SQL函数。
            支持子查询，即嵌套查询。
            支持动态绑定参数。

           Session类的Qurey接口支持HQL检索方式，它提供了以上列出的各种查询功能。

         注：Qurey接口支持方法链编程风格，它的set方法都返回自身实例，而不是返回void类型。方法链编程风格能使程序代码更加简洁。

    QBC检索方式

          采用HQL检索方式时，在应用程序中需要定义基于字符串形式的HQL查询语句。QBC API提供了检索对象的另一种方式，它主要由Criteria接口、Criterion接口和Expression类组成，它支持在运行时动态生成查询语句。

    本地SQL检索方式

           采用HQL或QBC检索方式时，Hibernate生成标准的SQL查询语句，使用于所有的数据库平台，因此这两种检索方式都是跨平台的。有的应用程序可能需要根据底层数据库的SQL方言，来生成一些特殊的查询语句。在这种情况下，可以利用Hibernate提供的SQL检索方式。

     

     

    抓取策略（优化）

    1.检索方式

    立即检索：立即查询，在执行查询语句时，立即查询所有的数据。

    延迟检索：延迟查询，在执行查询语句之后，在需要时在查询。（懒加载）

     

    2.检查策略

    类级别检索：当前的类的属性获取是否需要延迟。

    关联级别的检索：当前类 关联 另一个类是否需要延迟。

     

    3.类级别检索

    get：立即检索。get方法一执行，立即查询所有字段的数据。

    load：延迟检索。默认情况，load方法执行后，如果只使用OID的值不进行查询，如果要使用其他属性值将查询 。 Customer.hbm.xml <class  lazy="true |false">

                  lazy默认值true，表示延迟检索，如果设置false表示立即检索。

    1. get/load
    get: 立即查询数据库,将数据初始化
    load:  hbm文件中,class元素的lazy属性决定类级别load方法的加载策略
    true:先返回一个代理对象.使用代理对象的属性时,才去查询数据库.
    false: 与get一致,会立即加载数据

    [java] view plain copy
     
    1. @Test  
    2.     public void demo02() {  
    3.         //类级别  
    4.         Session session = factory.openSession();  
    5.         session.beginTransaction();  
    6.   
    7.         //1立即  
    8. //      Customer customer = (Customer) session.get(Customer.class, 1);  
    9.         //2延迟  
    10.         Customer customer = (Customer) session.load(Customer.class, 1);  
    11.           
    12.           
    13.           
    14.         //打印  
    15.         System.out.println(customer.getCid());  
    16.         System.out.println(customer.getCname());  
    17.   
    18.         session.getTransaction().commit();  
    19.         session.close();  
    20.     }  

    case：
    [java] view plain copy
     
    1. package com.itheima.b_lazy;  
    2.   
    3. import org.hibernate.Session;  
    4. import org.junit.Test;  
    5.   
    6. import com.itheima.domain.Course;  
    7. import com.itheima.domain.Customer;  
    8. import com.itheima.domain.Student;  
    9. import com.itheima.utils.HibernateUtils;  
    10.   
    11. public class Demo {  
    12.     @Test  
    13.     //类级别懒加载  
    14.     //load方法  
    15.     // class lazy属性  
    16.     // 默认值: true load获得时,会返回代理对象,不查询数据库.使用时才查询  
    17.     public void fun1(){  
    18.         Session session = HibernateUtils.openSession();  
    19.         session.beginTransaction();  
    20.         //------------------------------------------------  
    21.         Customer c = (Customer) session.load(Customer.class, 1);  
    22.           
    23.         System.out.println(c.getName());  
    24.         //------------------------------------------------  
    25.         session.getTransaction().commit();  
    26.         session.close(); // 游离状态  
    27.     }  
    28.     @Test  
    29.     //类级别懒加载  
    30.     //load方法  
    31.     // class lazy属性  
    32.     // lazy: false  load方法执行就会发送sql语句.与get方法一致.  
    33.     public void fun2(){  
    34.         Session session = HibernateUtils.openSession();  
    35.         session.beginTransaction();  
    36.         //------------------------------------------------  
    37.         Customer c = (Customer) session.load(Customer.class, 1);  
    38.           
    39.         System.out.println(c.getName());  
    40.         //------------------------------------------------  
    41.         session.getTransaction().commit();  
    42.         session.close(); // 游离状态  
    43.     }  
    44.       
    45. }  


    4.关联级别检索

    (1)一对多或多对多

    介绍：

    l  容器<set> 提供两个属性：fetch、lazy

           fetch：确定使用sql格式

           lazy：关联对象是否延迟。

    l  fetch：join、select、subselect

           join：底层使用迫切左外连接

           select：使用多个select语句（默认值）

           subselect：使用子查询

    l  lazy：false、true、extra

           false：立即

           true：延迟（默认值）

           extra：极其懒惰

     
     
     
     
     
    fetch="join"

    l  fetch="join" ，lazy无效。底层使用迫切左外连接，使用一条select将所有内容全部查询。

     
    [java] view plain copy
     
    1. @Test  
    2.     public void demo03() {  
    3.         //关联级别：一对多，  
    4.         // * Customer.hbm.xml  <set fetch="join">  
    5.         // *** select语句使用左外连接，一次性查询所有  
    6.         Session session = factory.openSession();  
    7.         session.beginTransaction();  
    8.   
    9.         //1 查询客户  
    10.         Customer customer = (Customer) session.get(Customer.class, 1);  
    11.         System.out.println(customer.getCname());  
    12.           
    13.         //2 查询客户订单数  
    14.         Set<Order> orderSet = customer.getOrderSet();  
    15.         System.out.println(orderSet.size());  
    16.           
    17.         //3 查询客户订单详情  
    18.         for (Order order : orderSet) {  
    19.             System.out.println(order);  
    20.         }  
    21.           
    22.   
    23.         session.getTransaction().commit();  
    24.         session.close();  
    25.     }  

    fetch="select"

    l  当前对象 和 关联对象 使用多条select语句查询。

    l  lazy="false" , 立即，先查询客户select，立即查询订单select

    l  lazy="true",延迟，先查询客户select，需要订单时，再查询订单select

    l  lazy="extra"，极其懒惰（延迟），先查询客户select， 如果只需要订单数，使用聚合函数（不查询详情）


     
     
     

    fetch="subselect"

    l  将使用子查询。注意：必须使用Query否则看不到效果。

    l  lazy= 同上

    [java] view plain copy
     
    1. @Test  
    2.     public void demo04() {  
    3.         //关联级别：一对多，  
    4.         // 演示3：* Customer.hbm.xml  <set fetch="subselect">  
    5.         Session session = factory.openSession();  
    6.         session.beginTransaction();  
    7.   
    8.         //1 查询客户  
    9.         List<Customer> allCustomer = session.createQuery("from Customer").list();  
    10.         Customer customer = allCustomer.get(0);  
    11.         System.out.println(customer.getCname());  
    12.           
    13.         //2 查询客户订单数  
    14.         Set<Order> orderSet = customer.getOrderSet();  
    15.         System.out.println(orderSet.size());  
    16.           
    17.         //3 查询客户订单详情  
    18.         for (Order order : orderSet) {  
    19.             System.out.println(order);  
    20.         }  
    21.           
    22.   
    23.         session.getTransaction().commit();  
    24.         session.close();  
    25.     }  
     


     
     
     
    关联级别加载策略
    在查询有关联关系的数据时,加载一方的数据是否需要将另一方立即查询出.
    默认: 与我关联的数据,在使用时才会加载.
    集合(一对多):
    set 
    lazy: 是否对set数据使用懒加载
    true:(默认值) 对集合使用才加载
    false: 集合将会被立即加载
    extra: 极其懒惰,如果使用集合时,之调用size方法查询数量, Hibernate会发送count语句,只查询数量.不加载集合内数据.
    fetch : 决定加载集合使用的sql语句种类
    select: (默认值) 普通select查询
    join: 表链接语句查询集合数据
    subselect: 使用子查询 一次加载多个Customer的订单数据
    case：
     
    配置：
    [html] view plain copy
     
    1. <?xml version="1.0" encoding="UTF-8"?>  
    2. <!DOCTYPE hibernate-mapping PUBLIC   
    3.     "-//Hibernate/Hibernate Mapping DTD 3.0//EN"  
    4.     "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">  
    5.  <hibernate-mapping package="com.itheima.domain" >  
    6.     <class name="Customer" table="t_customer"   >  
    7.         <id name="id" column="id"    >  
    8.             <generator class="native"></generator>  
    9.         </id>   
    10.         <!-- 告诉Hibernate , 乐观锁的版本号的属性名 -->  
    11.         <version name="version"></version>  
    12.               
    13.         <property name="name" column="name" type="string" ></property>  
    14.           
    15.         <!--   
    16.                 lazy : 是否对set数据使用懒加载  
    17.                 fetch : 决定加载集合使用的sql语句种类  
    18.          -->  
    19.         <set name="orders" batch-size="2"  >  
    20.             <!--  
    21.                 key 用来描述外键  
    22.                 column : 外键的值  
    23.               -->  
    24.             <key column="cid" ></key>  
    25.             <!-- one-to-many 表达, Customer 与orders 的关系是一对多  
    26.                 class: 表达关联的另一方的完整类名  
    27.              -->  
    28.             <one-to-many class="Order" />  
    29.         </set>  
    30.         <!-- 局部配置 -->  
    31.         <query name="bcd"><![CDATA[from Order]]></query>  
    32.     </class>  
    33.     <!-- 全局配置 -->  
    34.     <query name="abc"><![CDATA[from Customer]]></query>  
    35.  </hibernate-mapping>  


     
    Test：
    [java] view plain copy
     
    1. package com.itheima.b_lazy;  
    2.   
    3. import java.util.List;  
    4.   
    5. import org.hibernate.Session;  
    6. import org.junit.Test;  
    7.   
    8. import com.itheima.domain.Customer;  
    9. import com.itheima.domain.Order;  
    10. import com.itheima.utils.HibernateUtils;  
    11.   
    12. public class Demo2 {  
    13.     @Test  
    14.     //关联级别懒加载  
    15.     //默认: 与我关联的数据,在使用时才会加载.  
    16.     public void fun1(){  
    17.         Session session = HibernateUtils.openSession();  
    18.         session.beginTransaction();  
    19.         //------------------------------------------------  
    20.         Customer c = (Customer) session.get(Customer.class, 1);  
    21.           
    22.   
    23.         for(Order o : c.getOrders()){  
    24.             System.out.println(o.getName());  
    25.         }  
    26.           
    27.         //------------------------------------------------  
    28.         session.getTransaction().commit();  
    29.         session.close(); // 游离状态  
    30.     }  
    31.       
    32.       
    33.     @Test  
    34.     //关联级别懒加载  
    35.     //lazy: false  
    36.     public void fun2(){  
    37.         Session session = HibernateUtils.openSession();  
    38.         session.beginTransaction();  
    39.         //------------------------------------------------  
    40.         Customer c = (Customer) session.get(Customer.class, 1);  
    41.           
    42.   
    43.         for(Order o : c.getOrders()){  
    44.             System.out.println(o.getName());  
    45.         }  
    46.           
    47.         //------------------------------------------------  
    48.         session.getTransaction().commit();  
    49.         session.close(); // 游离状态  
    50.     }  
    51.       
    52.     @Test  
    53.     //关联级别懒加载  
    54.     //lazy: false/true  
    55.     //fetch:join  
    56.     public void fun3(){  
    57.         Session session = HibernateUtils.openSession();  
    58.         session.beginTransaction();  
    59.         //------------------------------------------------  
    60.         Customer c = (Customer) session.get(Customer.class, 1);  
    61.           
    62.   
    63.         for(Order o : c.getOrders()){  
    64.             System.out.println(o.getName());  
    65.         }  
    66.           
    67.         //------------------------------------------------  
    68.         session.getTransaction().commit();  
    69.         session.close(); // 游离状态  
    70.     }  
    71.       
    72.     @Test  
    73.     //关联级别懒加载  
    74.     //lazy:true  
    75.     //fetch:subselect  
    76.     public void fun4(){  
    77.         Session session = HibernateUtils.openSession();  
    78.         session.beginTransaction();  
    79.         //------------------------------------------------  
    80.             List<Customer> list = session.createQuery("from Customer").list();  
    81.               
    82.             for(Customer c:list){  
    83.                 System.out.println(c.getName()+"下单数量:"+c.getOrders().size());  
    84.             }  
    85.               
    86.         //------------------------------------------------  
    87.         session.getTransaction().commit();  
    88.         session.close(); // 游离状态  
    89.     }  
    90.       
    91.     @Test  
    92.     //关联级别懒加载  
    93.     //lazy:false  
    94.     //fetch:subselect  
    95.     public void fun5(){  
    96.         Session session = HibernateUtils.openSession();  
    97.         session.beginTransaction();  
    98.         //------------------------------------------------  
    99.             List<Customer> list = session.createQuery("from Customer").list();  
    100.               
    101.             for(Customer c:list){  
    102.                 System.out.println(c.getName()+"下单数量:"+c.getOrders().size());  
    103.             }  
    104.               
    105.         //------------------------------------------------  
    106.         session.getTransaction().commit();  
    107.         session.close(); // 游离状态  
    108.     }  
    109.       
    110.     @Test  
    111.     //关联级别懒加载  
    112.     //lazy:extra  
    113.     //fetch:select  
    114.     public void fun6(){  
    115.         Session session = HibernateUtils.openSession();  
    116.         session.beginTransaction();  
    117.         //------------------------------------------------  
    118.         //查询Customer  
    119.         Customer c = (Customer) session.get(Customer.class, 1);  
    120.         //查询Customer下订单 数量  
    121.         System.out.println(c.getOrders().size());  
    122.   
    123.         //真正使用订单中的数据  
    124.         for(Order o : c.getOrders()){  
    125.             System.out.println(o.getName());  
    126.         }  
    127.         //------------------------------------------------  
    128.         session.getTransaction().commit();  
    129.         session.close(); // 游离状态  
    130.     }  
    131.       
    132.     @SuppressWarnings("unchecked")  
    133.     @Test  
    134.     //关联级别懒加载  
    135.     //lazy:extra  
    136.     //fetch:subselect  
    137.     public void fun7(){  
    138.         Session session = HibernateUtils.openSession();  
    139.         session.beginTransaction();  
    140.         //------------------------------------------------  
    141.             List<Customer> list = session.createQuery("from Customer").list();  
    142.               
    143.             for(Customer c:list){  
    144.                 System.out.println(c.getName()+"下单数量:"+c.getOrders().size());  
    145.             }  
    146.               
    147.             for(Customer c:list){  
    148.                 for(Order o : c.getOrders()){  
    149.                     System.out.println(c.getName()+"下单名称:"+o.getName());  
    150.                       
    151.                 }  
    152.             }  
    153.               
    154.         //------------------------------------------------  
    155.         session.getTransaction().commit();  
    156.         session.close(); // 游离状态  
    157.     }  
    158. }  


    (2)多对一

    介绍：

    l  <many-to-one fetch="" lazy="">  (<one-to-one>)

    l  fetch取值：join、select

           join：底层使用迫切左外连接

           select：多条select语句

    l  lazy取值：false、proxy、no-proxy

           false：立即

           proxy：采用关联对象 类级别检索的策略。

                  订单 关联 客户 （多对一）

                  订单 立即获得 客户，需要在客户Customer.hbm.xml <class lazy="false">

                  订单 延迟获得 客户，需要在客户Customer.hbm.xml <classlazy="true">

           no-proxy不研究

    fetch="join"

    l  fecth="join" select语句使用左外连接，此时lazy无效。

    [java] view plain copy
     
    1. @Test  
    2.     public void demo05() {  
    3.         //关联级别：多对一，  
    4.         // 演示1：* Order.hbm.xml  <set fetch="join">  lazy无效  
    5.         // * 注意：检查Customer.hbm.xml 和 Order.hbm.xml 没有额外的配置  
    6.         Session session = factory.openSession();  
    7.         session.beginTransaction();  
    8.   
    9.         //1 查询订单  
    10.         Order order = (Order) session.get(Order.class, 1);  
    11.         System.out.println(order.getPrice());  
    12.           
    13.         //2 查询订单客户信息  
    14.         Customer customer = order.getCustomer();  
    15.         System.out.println(customer.getCname());  
    16.           
    17.   
    18.         session.getTransaction().commit();  
    19.         session.close();  
    20.     }  


    fetch="select"

    l  将采用多条select语句，lazy="proxy"是否延迟，取决关联对象 类级别检索策略。

    l  lazy="false"


    l  lazy="proxy"

     
     
     
    多对一:
    lazy
      false  加载订单时,会立即加载客户
      proxy  看客户对象的类加载策略来决定
      no-proxy : 不做研究. 
      fetch=
    select  : (默认值)使用普通select加载
    join : 使用表链接加载数据
     
     
    case：
    配置：
    [html] view plain copy
     
    1. <?xml version="1.0" encoding="UTF-8"?>  
    2. <!DOCTYPE hibernate-mapping PUBLIC   
    3.     "-//Hibernate/Hibernate Mapping DTD 3.0//EN"  
    4.     "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">  
    5.  <hibernate-mapping package="com.itheima.domain" >  
    6.     <class name="Order" table="t_order"  >  
    7.         <id name="id" column="id"    >  
    8.             <generator class="native"></generator>  
    9.         </id>       
    10.         <property name="name" column="name" type="string" ></property>  
    11.           
    12.         <!--   
    13.         lazy  
    14.             false  
    15.             proxy  
    16.             no-proxy : 不做研究.   
    17.         fetch=  
    18.             select  
    19.             join  
    20.         -->  
    21.         <many-to-one name="customer" column="cid" class="Customer"   ></many-to-one>  
    22.     </class>  
    23.  </hibernate-mapping>  


    Test：
    [java] view plain copy
     
    1. package com.itheima.b_lazy;  
    2.   
    3. import java.util.List;  
    4.   
    5. import org.hibernate.Session;  
    6. import org.junit.Test;  
    7.   
    8. import com.itheima.domain.Customer;  
    9. import com.itheima.domain.Order;  
    10. import com.itheima.utils.HibernateUtils;  
    11. //多对一检索策略  
    12. public class Demo3 {  
    13.     @Test  
    14.     //fetch: select  
    15.     //lazy: false  
    16.     public void fun1(){  
    17.         Session session = HibernateUtils.openSession();  
    18.         session.beginTransaction();  
    19.         //------------------------------------------------  
    20.         Order o = (Order) session.get(Order.class, 2);  
    21.           
    22.         System.out.println(o.getCustomer().getName());  
    23.           
    24.         //------------------------------------------------  
    25.         session.getTransaction().commit();  
    26.         session.close(); // 游离状态  
    27.     }  
    28.       
    29.       
    30.     @Test  
    31.     //fetch: select  
    32.     //lazy: proxy  
    33.     // Customer lazy:false  
    34.     public void fun2(){  
    35.         Session session = HibernateUtils.openSession();  
    36.         session.beginTransaction();  
    37.         //------------------------------------------------  
    38.         Order o = (Order) session.get(Order.class, 2);  
    39.           
    40.         System.out.println(o.getCustomer().getName());  
    41.           
    42.         //------------------------------------------------  
    43.         session.getTransaction().commit();  
    44.         session.close(); // 游离状态  
    45.     }  
    46.     @Test  
    47.     //fetch: select  
    48.     //lazy: proxy  
    49.     // Customer lazy:true  
    50.     public void fun3(){  
    51.         Session session = HibernateUtils.openSession();  
    52.         session.beginTransaction();  
    53.         //------------------------------------------------  
    54.         Order o = (Order) session.get(Order.class, 2);  
    55.           
    56.         System.out.println(o.getCustomer().getName());  
    57.           
    58.         //------------------------------------------------  
    59.         session.getTransaction().commit();  
    60.         session.close(); // 游离状态  
    61.     }  
    62.       
    63.     @Test  
    64.     //fetch: join  
    65.     //lazy: proxy|false  
    66.     public void fun4(){  
    67.         Session session = HibernateUtils.openSession();  
    68.         session.beginTransaction();  
    69.         //------------------------------------------------  
    70.         Order o = (Order) session.get(Order.class, 2);  
    71.           
    72.         System.out.println(o.getCustomer().getName());  
    73.           
    74.         //------------------------------------------------  
    75.         session.getTransaction().commit();  
    76.         session.close(); // 游离状态  
    77.     }  
    78. }  
  • 相关阅读:
    「题解」洛谷 P3487 [POI2009]ARC-Architects
    「题解」洛谷 P3512 [POI2010]PIL-Pilots
    CentOS中安装的Gitlab忘记管理员密码怎样重置密码
    Jenkins中安装Credentials Binding插件时提示:Failed to load: SSH Credentials Plugin (1.18.2),Jenkins(2.282)or higher required
    Jenkins中安装Role-based Authorization Strategy插件来实现用户角色权限管理
    信息系统项目管理师-项目范围管理考点笔记
    Jenkins修改插件下载地址为国内下载地址与安装中文插件
    CentOS中Jenkins的下载、安装、配置与启动(图文教程)
    Jenkins启动时提示:Starting Jenkins Jenkins requires Java8 or later, but you are running 1.7.0
    Gitlab怎样添加组、创建用户、创建项目与推送代码
  • 原文地址：https://www.cnblogs.com/GotoJava/p/7337050.html
Copyright © 2020-2023  润新知