关于AspectJ你可能不知道的那些事_whatisgame的博客-程序员宝宝

技术标签: JAVA  AOP  Spring  Aspectj  

转载:https://www.colabug.com/2102191.html 

请移步原链接查看原文

前两天看了一些关于spring aop以及AspectJ的文章,但是总是感觉非常的乱,有的说spring aop跟aspectj相互独立,有的说spring aop依赖于aspectj,有的甚至直接把两者混为一谈。很多专门讲Aspectj的文章也只是搬运了AspectJ的语法,就那么一两点东西,讲来讲去也没有什么新意。甚至很多甚至都是 面向IDE编程
(教你怎么安装插件,点击菜单),对AspectJ的使用方式和工作原理都不去分析,离开了IDE的支持甚至连编译都不会了。我认为咱们这些码农平时习惯用IDE并没有问题,但是不仅要做到 会用IDE
,而且要做到 超越IDE
,这样才能站到更高一点的视角看出工具的本来面目而不是受工具的局限。

当然,我吐槽了这么多其实并不是想标新立异,只是想找一个写文章的理由。虽然从某种方面讲,可能也算是” 茴香豆的X种写法
“,但是既然我自己乐在其中,那么开心就好喽。

为什么用AspectJ

为什么用AspectJ,我的理解是两个字” 方便
“。我们知道面向切面编程( Aspect Oriented Programming
)有诸多好处,但是在使用AspectJ之前我们一般是怎么编写切面的呢?我想一般来说应该是三种吧: 静态代理
, jdk动态代理
, cglib动态代理
。但是我们知道,静态代理的重用性太差,一个代理不能同事代理多种类;动态代理可以做到代理的重用,但是即使这样,他们调用起来还是比较麻烦,除了写切面代码以外,我们还需要将代理类耦合进被代理类的调用阶段,在创建被代理类的时候都要先创建代理类,再用代理类去创建被代理类,这就稍微有点麻烦了。比如我们想在现有的某个项目里统一新加入一些切面,这时候就需要创建切面并且侵入原有代码,在创建对象的时候添加代理,还是挺麻烦的。

说到底,这种麻烦出现的本质原因是,代理模式并没有做到切面与业务代码的解耦。虽然将切面的逻辑独立进了代理类,但是 决定是否使用切面的权利
仍然在业务代码中。这才导致了上面这种麻烦。

(当然,话不能说的这么绝对,如果有那种类似Spring的IoC容器,将类的创建都统一托管起来,我们只需要将切面用配置文件进行注册,容器会根据注册信息在创建bean的时候自动加上代理,这也是比较方便的。不过并不是所有框架都提供IoC机制的吧。。。)

既然代理模式这么麻烦,那么AspectJ又是通过什么方式来避免这个麻烦的呢?

我总结AspectJ提供了 两套
强大的机制:

第一套是 切面语法
。就是网上到处都是的那种所谓”AspectJ使用方法”,这套东西做到了将 决定是否使用切面的权利
还给了切面。在写切面的时候就可以决定哪些类的哪些方法会被代理,从而 从逻辑上
不需要侵入业务代码。由于这套语法实在是太有名,导致很多人都误以为AspectJ等于切面语法,其实不然。

第二套是 织入工具
。刚才讲到切面语法能够让切面 从逻辑上
与业务代码解耦,但是 从操作上
来讲,当JVM运行业务代码的时候,他甚至无从得知旁边还有个类想横插一刀。。。这个问题大概有两种解决思路,一种就是提供注册机制,通过额外的配置文件指明哪些类受到切面的影响,不过这还是需要干涉对象创建的过程;另外一种解决思路就是在编译期(或者类加载期)我们优先考虑一下切面代码,并将切面代码通过某种形式插入到业务代码中,这样业务代码不就知道自己被“切”了么?这种思路的一个实现就是 aspectjweaver
,就是这里的 织入工具

AspectJ究竟怎么用

一提起AspectJ,其实我感觉绝大多数人都会联想到Spring。毕竟,大多数人都是通过spring才接触到了AspectJ。可事实上Spring只是用到了AspectJ的冰山一角,局限于Spring恐怕是不能很好的理解AspectJ的,因此这一节我讲不涉及任何spring的东西,单看下AspectJ。

事实上AspectJ提供了两套对切面的描述方法,一种就是我们常见的 基于java注解
切面描述的方法,这种方法兼容java语法,写起来十分方便,不需要IDE的额外语法检测支持;另外一种是 基于aspect文件
的切面描述方法,这种语法本身并不是java语法,因此写的时候需要IDE的插件支持才能进行语法检查。

AspectJ相关jar包

AspectJ其实是eclipse基金会的一个项目, 官网
就在eclipse官网里。官网里提供了一个aspectJ.jar的下载链接,但其实这个链接只是一个安装包,把安装包里的东西解压后就是一个文档+脚本+jar包的程序包,其中比较重要的是如下部分:

[email protected]:~/aspectj1.8$ tree bin/ lib/
bin/
├── aj
├── aj5
├── ajbrowser
├── ajc
└── ajdoc
lib/
├── aspectjrt.jar
├── aspectjtools.jar
├── aspectjweaver.jar
└── org.aspectj.matcher.jar

当然,这些jar包并不总是需要从官网下载,很多情况下在maven等中心库中直接找会更方便。

这当中重点的文件是四个jar包中的前三个,bin文件夹中的脚本其实都是调用这些jar包的命令。

  • aspectjrt.jar包主要是提供 运行时
    的一些注解,静态方法等等东西,通常我们要使用aspectJ的时候都要使用这个包。
  • aspectjtools.jar包主要是提供赫赫有名的 ajc编译器
    ,可以在编译期将将java文件或者class文件或者aspect文件定义的切面织入到业务代码中。通常这个东西会被封装进各种IDE插件或者自动化插件中。
  • aspectjweaverjar包主要是提供了一个java agent用于在 类加载期
    间织入切面(Load time weaving)。并且提供了对切面语法的相关处理等基础方法,供ajc使用或者供第三方开发使用。这个包一般我们不需要显式引用,除非需要使用LTW。

上面的说明其实也就指出了aspectJ的几种标准的使用方法(参考 文档
):

  1. 编译时织入
    ,利用ajc编译器替代javac编译器,直接将源文件(java或者aspect文件)编译成class文件并将切面织入进代码。
  2. 编译后织入
    ,利用ajc编译器向javac编译期编译后的class文件或jar文件织入切面代码。
  3. 加载时织入
    ,不使用ajc编译器,利用aspectjweaver.jar工具,使用java agent代理在类加载期将切面织入进代码。

基于aspectj文件的AspectJ

这种说法比较蛋疼,其实我想说明的是这种不兼容javac的一种切面表示形式。比如当前我们有一个业务类App.java:

public class App{

    public void say(){
        System.out.println("App say");
    }

    public static void main(String[] args){
        App app = new App();
        app.say();
    }
}

我们希望对在say函数里加一个切面,那就创建一个AjAspectj.aj的文件:

public aspect AjAspect {

    pointcut say():
            execution(* App.say(..));
    before(): say() {
        System.out.println("AjAspect before say");
    }
    after(): say() {
        System.out.println("AjAspect after say");
    }
}

这样我们就能实现切面的功能。可这个aj文件的语法虽然跟java很类似,但是毕竟还是不能用javac来编译,如果我们要用这个的话就必须使用ajc编译器。使用的方法大概有这几种:

  1. 调用命令
    直接编译(直接使用ajc命令或者调用java -jar aspectjtools.jar)
  2. 使用 IDE集成
    的ajc编译器编译
  3. 使用 自动化构建工具
    的插件编译 
    其实2,3两点的本质都是使用aspectjtools.jar,最简单的调用方法如下:

     

    #!/usr/bin/env bash
    
    ASPECTJ_TOOLS=/home/myths/.m2/repository/org/aspectj/aspectjtools/1.8.9/aspectjtools-1.8.9.jar
    ASPECTJ_RT=/home/myths/.m2/repository/org/aspectj/aspectjrt/1.8.9/aspectjrt-1.8.9.jar
    
    java -jar $ASPECTJ_TOOLS -cp $ASPECTJ_RT -sourceroots .
    

调用aspectjtools.jar包,指定aspectjrt的classpath,以及需要编译的路径,这样就会生成AjAspectj.aj以及App.java对应的class文件。我们反编译一下看看:

AjAspectj.class:

import java.io.PrintStream;
import org.aspectj.lang.NoAspectBoundException;

public class AjAspect
{
  private static Throwable ajc$initFailureCause;
  public static final AjAspect ajc$perSingletonInstance;
  
  public static AjAspect aspectOf()
  {
    if (ajc$perSingletonInstance == null) {
      throw new NoAspectBoundException("AjAspect", ajc$initFailureCause);
    }
    return ajc$perSingletonInstance;
  }
  
  public static boolean hasAspect()
  {
    return ajc$perSingletonInstance != null;
  }
  
  private static void ajc$postClinit()
  {
    ajc$perSingletonInstance = new AjAspect();
  }
  
  static
  {
    try
    {
      
    }
    catch (Throwable localThrowable)
    {
      ajc$initFailureCause = localThrowable;
    }
  }
  
  public void ajc$before$AjAspect$1$682722c()
  {
    System.out.println("AjAspect before say");
  }
  
  public void ajc$after$AjAspect$2$682722c()
  {
    System.out.println("AjAspect after say");
  }
}

App.class:

import java.io.PrintStream;

public class App
{
  public void say()
  {
    try
    {
      AjAspect.aspectOf().ajc$before$AjAspect$1$682722c();System.out.println("App say");
    }
    catch (Throwable localThrowable)
    {
      AjAspect.aspectOf().ajc$after$AjAspect$2$682722c();throw localThrowable;
    }
    AjAspect.aspectOf().ajc$after$AjAspect$2$682722c();
  }
  
  public static void main(String[] args)
  {
    App app = new App();
    app.say();
  }
}

调用App.class,发现切面成功生效:

$ java -cp ~/.m2/repository/org/aspectj/aspectjrt/1.8.9/aspectjrt-1.8.9.jar:.  App
AjAspect before say
App say
AjAspect after say

我们发现aj文件的确被编译成了一个单例类,并且生成了一些切面方法,这些方法被织入进了App类中的say方法体中,可以说是非常的暴力了。(这里顺便吐槽一波IntelliJ自带的反编译器真的很 
,还是 jd-gui
好用)。

不过,虽然事实上这种基于aj文件的切面描述方法比基于java注解的切面描述方法用起来要 灵活的多
,但是由于他无法摆脱ajc的支持,而且本身不兼容java语法导致难以统一编码规范,加上需要较多额外的学习成本,因此事实上很多项目还是不怎么用这种方式,更多的还是采用了兼容java语法的用注解定义切面的方式。

基于java注解的AspectJ

下面我们主要还是着力考虑下基于java注解的切面使用方法。

准备

先建一个普通的项目看看,老样子,从maven的maven-archetype-quickstart开始,pom.xml,pom文件里我们一般只需要加上aspetjrt的依赖即可。:

    4.0.0

    com.mythsman.test
    aspect-test
    1.0-SNAPSHOT
    jar

    work
    http://maven.apache.org

    
        UTF-8
    

    
        
            org.aspectj
            aspectjrt
            1.8.9
        
    
    
    
        
            
                org.apache.maven.plugins
                maven-compiler-plugin
                3.7.0
                
                    1.8
                    1.8
                
        
    

创建App.java文件:

package com.mythsman.test;

public class App{

    public void say(){
        System.out.println("App say");
    }

    public static void main(String[] args){
        App app = new App();
        app.say();
    }
}

创建切面类AnnoAspect.java:

package com.mythsman.test;

import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;

@Aspect
public class AnnoAspect{

    @Pointcut("execution(* com.mythsman.test.App.say(..))")
    public void jointPoint(){
    }

    @Before("jointPoint()")
    public void before(){
        System.out.println("AnnoAspect before say");
    }


    @After("jointPoint()")
    public void after(){
        System.out.println("AnnoAspect after say");
    }

}

当前项目结构应该是这样的:

.
├── pom.xml
├── src
│   └── main
│       ├── java
│       │   └── com
│       │       └── mythsman
│       │           └── test
│       │               └── App.java
│       │               ├── AnnoAspect.java

其实就是创建了一个对App类进行切面的AnnoAspect类,这个类需要加上@Aspect注解用以声明这是一个切面,以及其他相关切面语法。接下来我们就来尝试下三种不同的编译方式。

编译时织入

编译时织入其实就是使用ajc来进行编译,暂时不使用自动化构建工具,我们先在项目根目录下手动写一个编译脚本compile.sh:

#!/usr/bin/env bash
ASPECTJ_WEAVER=/home/myths/.m2/repository/org/aspectj/aspectjweaver/1.8.13/aspectjweaver-1.8.13.jar
ASPECTJ_RT=/home/myths/.m2/repository/org/aspectj/aspectjrt/1.8.9/aspectjrt-1.8.9.jar
ASPECTJ_TOOLS=/home/myths/.m2/repository/org/aspectj/aspectjtools/1.8.9/aspectjtools-1.8.9.jar

java -jar $ASPECTJ_TOOLS -cp $ASPECTJ_RT -source 1.5 -sourceroots src/main/java/ -d target/classes

调用aspectjtools.jar,在-cp里指明aspectjrt.jar的路径,-source 1.5指明支持java1.5以后的注解,-sourceroots指明编译的文件夹,-d指明输出路径。

这样就会生成AnnoAspect.class和App.class两个文件。

AnnoAspect.class:

package com.mythsman.test;

import java.io.PrintStream;
import org.aspectj.lang.NoAspectBoundException;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;

@Aspect
public class AnnoAspect
{
  public static AnnoAspect aspectOf()
  {
    if (ajc$perSingletonInstance == null) {
      throw new NoAspectBoundException("com.mythsman.test.AnnoAspect", ajc$initFailureCause);
    }
    return ajc$perSingletonInstance;
  }
  
  public static boolean hasAspect()
  {
    return ajc$perSingletonInstance != null;
  }
  
  static
  {
    try
    {
      ajc$postClinit();
    }
    catch (Throwable localThrowable)
    {
      ajc$initFailureCause = localThrowable;
    }
  }
  
  @Before("jointPoint()")
  public void before()
  {
    System.out.println("AnnoAspect before say");
  }
  
  @After("jointPoint()")
  public void after()
  {
    System.out.println("AnnoAspect after say");
  }
}

App.class

package com.mythsman.test;

import java.io.PrintStream;

public class App
{
  public void say()
  {
    try
    {
      AnnoAspect.aspectOf().before();System.out.println("App say");
    }
    catch (Throwable localThrowable)
    {
      AnnoAspect.aspectOf().after();throw localThrowable;
    }
    AnnoAspect.aspectOf().after();
  }
  
  public static void main(String[] args)
  {
    App app = new App();
    app.say();
  }
}

我们发现ajc对AnnoAspect的处理方法与跟AjAspect的处理方法类似,都是将类声明成单例,并且识别AspectJ语法,将相关函数织入到App中。

运行(在项目根目录执行):

$ java -cp ~/.m2/repository/org/aspectj/aspectjrt/1.8.9/aspectjrt-1.8.9.jar:src/main/java/ com.mythsman.test.App 
AnnoAspect before say
App say
AnnoAspect after say

编译后织入

编译后织入其实就是在javac编译完成后,用ajc再去处理class文件得到新的、织入过切面的class文件。

仍然是上面的项目,我们先用javac编译一下:

$ javac -cp ~/.m2/repository/org/aspectj/aspectjrt/1.8.9/aspectjrt-1.8.9.jar  -d target/classes src/main/java/com/mythsman/test/*.java

编译成功后生成了AnnoAspect.class以及App.class。显然,这两个class文件反编译后还是源文件的样子,并没有什么用,因此这时候执行App的main函数发现切面并没有生效。因此我们仍然需要用ajc来处理:

!/usr/bin/env bash
ASPECTJ_WEAVER=/home/myths/.m2/repository/org/aspectj/aspectjweaver/1.8.13/aspectjweaver-1.8.13.jar
ASPECTJ_RT=/home/myths/.m2/repository/org/aspectj/aspectjrt/1.8.9/aspectjrt-1.8.9.jar
ASPECTJ_TOOLS=/home/myths/.m2/repository/org/aspectj/aspectjtools/1.8.9/aspectjtools-1.8.9.jar

java -jar $ASPECTJ_TOOLS -cp $ASPECTJ_RT -source 1.5 -inpath target/classes -d target/classes

这样就把target/classes中原来的class文件替换成了织入后的class文件。反编译之后发现与采用 编译期织入
方法的结果基本相同。

加载时织入(LTW)

前两种织入方法都依赖于ajc的编译工具,LTW却通过java agent机制在内存中操作类文件,可以不需要ajc的支持做到 动态织入

不过,这里有一个挺有意思的问题,我们知道编译期一定会编译AnnoAspect类,那么这时候通过切面语法我们就可以找到他要处理的App类,这大概就是编译阶段织入的大概流程。但是如果在类加载期处理的话,当类加载到App类的时候,我们并不知道这个类需要被AnnoAspect处理。。。因此为了实现LTW,我们肯定要有个配置文件,来告诉类加载器,某某某切面需要优先考虑,他们很可能会影响其他的类。

为了实现LTW,我们需要在资源目录下配置META-INF/aop.xml文件,来告知类加载器我们当前注册的切面。

在上面的项目中,我们其实只需要创建src/main/resources/META-INF/aop.xml:

 

这样,我们就可以先使用javac编译源文件,再使用java agent在运行时织入:

#!/usr/bin/env bash
ASPECTJ_WEAVER=/home/myths/.m2/repository/org/aspectj/aspectjweaver/1.8.13/aspectjweaver-1.8.13.jar
ASPECTJ_RT=/home/myths/.m2/repository/org/aspectj/aspectjrt/1.8.9/aspectjrt-1.8.9.jar
ASPECTJ_TOOLS=/home/myths/.m2/repository/org/aspectj/aspectjtools/1.8.9/aspectjtools-1.8.9.jar

java -javaagent:$ASPECTJ_WEAVER -cp $ASPECTJ_RT:target/classes/ com.mythsman.test.App

运行结果:

AnnoAspect before say
App say
AnnoAspect after say

当然,如果可以使用ajc的话,我们也可以通过-outxml参数来自动生成xml文件。

maven自动化构建

显然,自己写脚本还是比较麻烦的,如果用如maven这样的自动化构建工具的话就会方便很多,codehaus提供了一个ajc的编译插件aspectj-maven-plugin,我们只需要在build/plugins标签下加上这个插件的配置即可:

    org.codehaus.mojo
    aspectj-maven-plugin
    1.10
    
        1.8
        1.8
        1.8
    
    
        
            
                compile
            
        
    

这个插件会绑定到编译期,采用的应该是编译后织入的方式,在maven-compiler-plugin处理完之后再工作的。

不要以为这个插件多厉害,说白了他其实就是对aspectjtools.jar的一个mojo 封装
而已,去看他的依赖树就会很清楚。

如何判断是织入还是代理

这个问题很有意思,也是非常容易被搞混的,尤其是在讨论spring aop的时候。我们知道spring里有很多基于动态代理的设计,而我们知道动态代理也可以被用作面向切面的编程,但是spring aop本身却支持aspectj的切面语法,而且spring-aop这个包也引用了aspectj,我们知道aspectj是通过织入的方式来实现aop的。。。那么 spring aop究竟是通过织入还是代理来实现aop的呢

没错就是动态代理

其实spring aop还是通过 动态代理
来实现aop的,即使不去看他的源码,我们也可以通过简单的实验来得到这个结论。

根据aspectj的使用方式,我们知道,如果要向代码中织入切面,那么我们要么采用ajc编译,要么使用aspectjweaver的agent代理。但是spring既没有依赖任何aspectjtools的相关jar包,虽然依赖了aspectjweaver这个包,但是并没有添加agent代理。当然,也存在一种可能就是spring利用aspectjweaver这个包自己实现了动态织入,但是从可复用的角度讲,spring真的会自己重新造轮子?如果真的重新造了那为啥不脱离aspectj彻底重新造,而是用一半造一半呢?

而且,我们知道用织入和用动态代理有一个很大的区别,如果使用织入的话,那么调业务对象的getClass()方法获得的类名就是这个类本身实现的类名;但是如果使用动态代理的话,调用getClass()方法获得的类名就是动态代理类的类名了。做一个简单的实验我们就可以发现,如果我们使用spring aop来对某一个service进行切面处理,那么调用getClass()方法获得的结果就是:

com.mythsman.test.Myservice$$EnhancerBySpringCGLIB$$3afc9148

显然,虽然spring aop采用了aspectj语法来定义切面,但是在实现切面逻辑的时候还是采用CGLIB来进行动态代理的方法。

强行织入?

当然,如果我们想,我们也可以强行采用织入的方式,不过我们就不能将切面类注册为spring的bean,并且采用ajc插件编译或者java agent在类加载时织入。

版权声明:本文为博主原创文章,遵循 CC 4.0 BY-SA 版权协议,转载请附上原文出处链接和本声明。
本文链接:https://blog.csdn.net/whatigame/article/details/103173308

智能推荐

uniapp 微信分享(ios)_A_Brave的博客-程序员宝宝

ios分享首先项目的打开manifest.json,找到App模块配置,勾选微信分享会弹出一个Android和ios的配置项,ios分享需要的是一个UniversalLinks链接1.进入苹果开发者后台,点击Certificates, IDs & Profiles2.如果之前创建过id,就直接点击进去可以修改,如果没有就点击新建一个id,勾选Associated Domains注意:如果你之前生成过打包用的profile文件,修改之后打包需要在Profiles里面重新下载一个.mo

文字尺寸、宽高的测量 Paint FontMetrics_H_MZ的博客-程序员宝宝

Paint.FontMetrics类简介Google文档中的描述:/** * Class that describes the various各种 metrics指标 for a font at a given text size. * Remember, Y values increase going down, so those values will be positive正数, * and...

LB_Kim_weixin_30755709的博客-程序员宝宝

LB_Kim搜了一圈发现居然很少有博客说到这个东西, LB_Kim, 就是Kim设计的 下界函数计算公式: LB_Kim(S,C)=MAX(i=1,2,3,4) d(∮(i)A,∮(i)C)emmm,公式还是上图片吧其中: f1x=x1, f2x=x|x|, f3x=min(x), f4x=max(x).通过以上4个特征构建时间序列, 4个特征由时间序列的首尾两点、最大值和最小值构成,...

public class Registe { private void button1ActionPerformed(ActionEvent e) {//注册按钮响应事件 if(textFie_wuadasda的博客-程序员宝宝

public class Registe {private void button1ActionPerformed(ActionEvent e) {//注册按钮响应事件if(textField1.getText().equals("")||textField2.getText().equals("")||textField3.getText().equals("")||textField4.getText().equals("")){JOptionPane.showMessageDialog(null

bzoj1257: [CQOI2007]余数之和sum_IED98的博客-程序员宝宝

直接按取整相同的数分块就可以了,可以证明不会大于sqrt(n)块。#include #include #include #include #include using namespace std;long long n,k,pos;long long ans;int main(){ scanf("%lld%lld",&n,&k); long long tmp=

Learn OpenGL(五)——定义自己的着色器_ooMelloo的博客-程序员宝宝

定义自己的着色器       编写、编译、管理着色器是件麻烦事。在着色器的最后主题里,我们会写一个类来让我们的生活轻松一点,这个类从硬盘读着色器,然后编译和链接它们,对它们进行错误检测,这就变得很好用了。这也会给你一些关于如何把我们目前所学的知识封装到一个抽象的对象里的灵感。       我们会在头文件里创建整个类,主要为了学习,也可以方便移植。我们先来添加必要的include,定义类结构...

随便推点

Java 17 正式发布 ,Oracle 推出免费JDK许可证_大佛拈花的博客-程序员宝宝_java oracle 许可

一个小时前,JAVA 17 正式发布,这是一个LTS(长期支持)版本,带来了不少有用的新特性。关于Java 17 的一些新特性,胖哥已经在往期的文章中进行了介绍,这里就不再赘述了,有兴趣的可以移步文章 Java 17 新特性确定 。Oracle 免费 JDKJAVA 17 带来的不仅仅是新功能。更快的 LTS 节奏和免费的 Oracle JDK 使其成为有史以来支持最好的现代版本。Oracle JDK收费为人诟病,此次Oracle推出了Free Java License ,大致摘要:Oracl..

NLP第3课:动手实战中文文本中的关键字提取_米饭超人的博客-程序员宝宝

前言 关键词提取就是从文本里面把跟这篇文章意义最相关的一些词语抽取出来。这个可以追溯到文献检索初期,关键词是为了文献标引工作,从报告、论文中选取出来用以表示全文主题内容信息的单词或术语,在现在的报告和论文中,我们依然可以看到关键词这一项。因此,关键词在文献检索、自动文摘、文本聚类/分类等方面有着重要的应用,它不仅是进行这些工作不可或缺的基础和前提,也是互联网上信息建库的一项...

python解析truelicense_vah101的博客-程序员宝宝

from truepy import Licenseimport stringimport xml.dom.minidom as xmldomimport osimport xml.etree.ElementTree as ETtry:# Load the certificate with open('certf.cer', 'r') as f: certific...

ubuntu18设置安装mysql 5.7并设置远程访问_libingjy的博客-程序员宝宝

网上流传的方法都试了,都是坑,以下方法亲试可以1、sudo apt install mysql-server2、使用sudo 命令登录Mysql,此时不需要密码,3、修改root账号密码update user set authentication_string = password('你的密码'), password_expired = 'N', password_last_chan...

WAF2开发FAQ汇总_最爱天蓝色_Sky1的博客-程序员宝宝

1.单头F7控件添加过滤条件//给节点字段添加过滤条件waf("#prmtAcceptNode").wafPromptStandard("option", "filteritem", "acceptContract.id='" + acceptContract.id + "'");

LeetCode1744 / 牛客:万万没想到之聪明的编辑(体验ACM模式)_Zephyr丶J的博客-程序员宝宝

1744. 你能在你最喜欢的那天吃到你最喜欢的糖果吗?2021.6.1 每日一题,也祝大家节日快乐啊题目描述给你一个下标从 0 开始的正整数数组 candiesCount ,其中 candiesCount[i] 表示你拥有的第 i 类糖果的数目。同时给你一个二维数组 queries ,其中 queries[i] = [favoriteTypei, favoriteDayi, dailyCapi] 。你按照如下规则进行一场游戏:你从第 0 天开始吃糖果。你在吃完 所有 第 i - 1 类糖果之

推荐文章

热门文章

相关标签