精华内容
下载资源
问答
  • java 调用规则

    千次阅读 2011-04-22 14:21:00
    除了规则配置器嵌入的页面配置器生成的jsp页面,调用规则包之外,其他的java工程如果要调用此规则包,可以通过规则引擎类类进行调用。以下演示eclipse中java工程如何调用规则包。 设置java工程路径   首先在...

    除了规则配置器嵌入的页面配置器生成的jsp页面,调用规则包之外,其他的java工程如果要调用此规则包,可以通过规则引擎类类进行调用。以下演示eclipsejava工程如何调用规则包。

    设置java工程路径

           首先在eclipsejava工程中,点击属性设置其路径。在其属性窗口的Java Build Path中设置Libraries,通过Add External JARs…加入VisualRules安装目录的lib下的engine.jar,在通过Add External Class Folder…加入VisualRules安装目录下的rules目录。如下所示:

    添加Java测试类

           java工程中添加一个java类,名为TestHello.java,其内容编辑如下:

    import com.flagleader.engine.RuleEngine;

    import com.flagleader.engine.RuleEngineFactory;

    public class TestHello {

           public static void main(String[] args) {

                  try {

                         RuleEngine engine = RuleEngineFactory.newInstance().getRuleEngine();

                         engine.put("name", "访问测试");

                         engine.excute("hello");

                         System.out.println(engine.getString("welcome"));

                  } catch (Exception e) {

                         e.printStackTrace() ;

                  }

           }

    }

    执行java测试类

           点击执行后,可以看到如下结果:

     

     

     

    说明已经调用了hello规则包,并且根据传入的name值“访问测试”,返回处理结果是 hello+“访问测试”。

           同理,任何的其他java类,只需加入上述的代码,即可完成调用规则包的工作。

     

     

    展开全文
  • 深入理解Java类加载器(ClassLoader)

    万次阅读 多人点赞 2017-06-26 09:34:08
    【版权申明】未经博主同意,谢绝转载!(请尊重原创,博主保留追究权) ...深入理解Java类型信息(Class对象)与反射机制 深入理解Java枚举类型(enum) 深入理解Java注解类型(@Annotation) 深入理解

    【版权申明】未经博主同意,谢绝转载!(请尊重原创,博主保留追究权)
    http://blog.csdn.net/javazejian/article/details/73413292
    出自【zejian的博客】

    关联文章:

    深入理解Java类型信息(Class对象)与反射机制

    深入理解Java枚举类型(enum)

    深入理解Java注解类型(@Annotation)

    深入理解Java类加载器(ClassLoader)

    深入理解Java并发之synchronized实现原理

    Java并发编程-无锁CAS与Unsafe类及其并发包Atomic

    深入理解Java内存模型(JMM)及volatile关键字

    剖析基于并发AQS的重入锁(ReetrantLock)及其Condition实现原理

    剖析基于并发AQS的共享锁的实现(基于信号量Semaphore)

    并发之阻塞队列LinkedBlockingQueue与ArrayBlockingQueue

    本篇博文主要是探讨类加载器,同时在本篇中列举的源码都基于Java8版本,不同的版本可能有些许差异。主要内容如下

    文章目录


    #类加载的机制的层次结构
    每个编写的".java"拓展名类文件都存储着需要执行的程序逻辑,这些".java"文件经过Java编译器编译成拓展名为".class"的文件,".class"文件中保存着Java代码经转换后的虚拟机指令,当需要使用某个类时,虚拟机将会加载它的".class"文件,并创建对应的class对象,将class文件加载到虚拟机的内存,这个过程称为类加载,这里我们需要了解一下类加载的过程,如下:

    • 加载:类加载过程的一个阶段:通过一个类的完全限定查找此类字节码文件,并利用字节码文件创建一个Class对象

    • 验证:目的在于确保Class文件的字节流中包含信息符合当前虚拟机要求,不会危害虚拟机自身安全。主要包括四种验证,文件格式验证,元数据验证,字节码验证,符号引用验证。

    • 准备:为类变量(即static修饰的字段变量)分配内存并且设置该类变量的初始值即0(如static int i=5;这里只将i初始化为0,至于5的值将在初始化时赋值),这里不包含用final修饰的static,因为final在编译的时候就会分配了,注意这里不会为实例变量分配初始化,类变量会分配在方法区中,而实例变量是会随着对象一起分配到Java堆中。

    • 解析:主要将常量池中的符号引用替换为直接引用的过程。符号引用就是一组符号来描述目标,可以是任何字面量,而直接引用就是直接指向目标的指针、相对偏移量或一个间接定位到目标的句柄。有类或接口的解析,字段解析,类方法解析,接口方法解析(这里涉及到字节码变量的引用,如需更详细了解,可参考《深入Java虚拟机》)。

    • 初始化:类加载最后阶段,若该类具有超类,则对其进行初始化,执行静态初始化器和静态初始化成员变量(如前面只初始化了默认值的static变量将会在这个阶段赋值,成员变量也将被初始化)。

    这便是类加载的5个过程,而类加载器的任务是根据一个类的全限定名来读取此类的二进制字节流到JVM中,然后转换为一个与目标类对应的java.lang.Class对象实例,在虚拟机提供了3种类加载器,引导(Bootstrap)类加载器、扩展(Extension)类加载器、系统(System)类加载器(也称应用类加载器),下面分别介绍
    ##启动(Bootstrap)类加载器
    启动类加载器主要加载的是JVM自身需要的类,这个类加载使用C++语言实现的,是虚拟机自身的一部分,它负责将 <JAVA_HOME>/lib路径下的核心类库或-Xbootclasspath参数指定的路径下的jar包加载到内存中,注意必由于虚拟机是按照文件名识别加载jar包的,如rt.jar,如果文件名不被虚拟机识别,即使把jar包丢到lib目录下也是没有作用的(出于安全考虑,Bootstrap启动类加载器只加载包名为java、javax、sun等开头的类)。

    ##扩展(Extension)类加载器
    扩展类加载器是指Sun公司(已被Oracle收购)实现的sun.misc.Launcher$ExtClassLoader类,由Java语言实现的,是Launcher的静态内部类,它负责加载<JAVA_HOME>/lib/ext目录下或者由系统变量-Djava.ext.dir指定位路径中的类库,开发者可以直接使用标准扩展类加载器。

    //ExtClassLoader类中获取路径的代码
    private static File[] getExtDirs() {
         //加载<JAVA_HOME>/lib/ext目录中的类库
         String s = System.getProperty("java.ext.dirs");
         File[] dirs;
         if (s != null) {
             StringTokenizer st =
                 new StringTokenizer(s, File.pathSeparator);
             int count = st.countTokens();
             dirs = new File[count];
             for (int i = 0; i < count; i++) {
                 dirs[i] = new File(st.nextToken());
             }
         } else {
             dirs = new File[0];
         }
         return dirs;
     }
    
    

    ##系统(System)类加载器
    也称应用程序加载器是指 Sun公司实现的sun.misc.Launcher$AppClassLoader。它负责加载系统类路径java -classpath-D java.class.path 指定路径下的类库,也就是我们经常用到的classpath路径,开发者可以直接使用系统类加载器,一般情况下该类加载是程序中默认的类加载器,通过ClassLoader#getSystemClassLoader()方法可以获取到该类加载器。
      在Java的日常应用程序开发中,类的加载几乎是由上述3种类加载器相互配合执行的,在必要时,我们还可以自定义类加载器,需要注意的是,Java虚拟机对class文件采用的是按需加载的方式,也就是说当需要使用该类时才会将它的class文件加载到内存生成class对象,而且加载某个类的class文件时,Java虚拟机采用的是双亲委派模式即把请求交由父类处理,它一种任务委派模式,下面我们进一步了解它。
    #理解双亲委派模式

    ##双亲委派模式工作原理
    双亲委派模式要求除了顶层的启动类加载器外,其余的类加载器都应当有自己的父类加载器,请注意双亲委派模式中的父子关系并非通常所说的类继承关系,而是采用组合关系来复用父类加载器的相关代码,类加载器间的关系如下:

    双亲委派模式是在Java 1.2后引入的,其工作原理的是,如果一个类加载器收到了类加载请求,它并不会自己先去加载,而是把这个请求委托给父类的加载器去执行,如果父类加载器还存在其父类加载器,则进一步向上委托,依次递归,请求最终将到达顶层的启动类加载器,如果父类加载器可以完成类加载任务,就成功返回,倘若父类加载器无法完成此加载任务,子加载器才会尝试自己去加载,这就是双亲委派模式,即每个儿子都很懒,每次有活就丢给父亲去干,直到父亲说这件事我也干不了时,儿子自己想办法去完成,这不就是传说中的实力坑爹啊?那么采用这种模式有啥用呢?

    ##双亲委派模式优势
    采用双亲委派模式的是好处是Java类随着它的类加载器一起具备了一种带有优先级的层次关系,通过这种层级关可以避免类的重复加载,当父亲已经加载了该类时,就没有必要子ClassLoader再加载一次。其次是考虑到安全因素,java核心api中定义类型不会被随意替换,假设通过网络传递一个名为java.lang.Integer的类,通过双亲委托模式传递到启动类加载器,而启动类加载器在核心Java API发现这个名字的类,发现该类已被加载,并不会重新加载网络传递的过来的java.lang.Integer,而直接返回已加载过的Integer.class,这样便可以防止核心API库被随意篡改。可能你会想,如果我们在classpath路径下自定义一个名为java.lang.SingleInterge类(该类是胡编的)呢?该类并不存在java.lang中,经过双亲委托模式,传递到启动类加载器中,由于父类加载器路径下并没有该类,所以不会加载,将反向委托给子类加载器加载,最终会通过系统类加载器加载该类。但是这样做是不允许,因为java.lang是核心API包,需要访问权限,强制加载将会报出如下异常

    java.lang.SecurityException: Prohibited package name: java.lang
    

    所以无论如何都无法加载成功的。下面我们从代码层面了解几个Java中定义的类加载器及其双亲委派模式的实现,它们类图关系如下

    从图可以看出顶层的类加载器是ClassLoader类,它是一个抽象类,其后所有的类加载器都继承自ClassLoader(不包括启动类加载器),这里我们主要介绍ClassLoader中几个比较重要的方法。

    • loadClass(String)

      该方法加载指定名称(包括包名)的二进制类型,该方法在JDK1.2之后不再建议用户重写但用户可以直接调用该方法,loadClass()方法是ClassLoader类自己实现的,该方法中的逻辑就是双亲委派模式的实现,其源码如下,loadClass(String name, boolean resolve)是一个重载方法,resolve参数代表是否生成class对象的同时进行解析相关操作。:

      protected Class<?> loadClass(String name, boolean resolve)
            throws ClassNotFoundException
        {
            synchronized (getClassLoadingLock(name)) {
                // 先从缓存查找该class对象,找到就不用重新加载
                Class<?> c = findLoadedClass(name);
                if (c == null) {
                    long t0 = System.nanoTime();
                    try {
                        if (parent != null) {
                            //如果找不到,则委托给父类加载器去加载
                            c = parent.loadClass(name, false);
                        } else {
                        //如果没有父类,则委托给启动加载器去加载
                            c = findBootstrapClassOrNull(name);
                        }
                    } catch (ClassNotFoundException e) {
                        // ClassNotFoundException thrown if class not found
                        // from the non-null parent class loader
                    }
      
                    if (c == null) {
                        // If still not found, then invoke findClass in order
                        // 如果都没有找到,则通过自定义实现的findClass去查找并加载
                        c = findClass(name);
      
                        // this is the defining class loader; record the stats
                        sun.misc.PerfCounter.getParentDelegationTime().addTime(t1 - t0);
                        sun.misc.PerfCounter.getFindClassTime().addElapsedTimeFrom(t1);
                        sun.misc.PerfCounter.getFindClasses().increment();
                    }
                }
                if (resolve) {//是否需要在加载时进行解析
                    resolveClass(c);
                }
                return c;
            }
        }
      

      正如loadClass方法所展示的,当类加载请求到来时,先从缓存中查找该类对象,如果存在直接返回,如果不存在则交给该类加载去的父加载器去加载,倘若没有父加载则交给顶级启动类加载器去加载,最后倘若仍没有找到,则使用findClass()方法去加载(关于findClass()稍后会进一步介绍)。从loadClass实现也可以知道如果不想重新定义加载类的规则,也没有复杂的逻辑,只想在运行时加载自己指定的类,那么我们可以直接使用this.getClass().getClassLoder.loadClass("className"),这样就可以直接调用ClassLoader的loadClass方法获取到class对象。

    • findClass(String)
      在JDK1.2之前,在自定义类加载时,总会去继承ClassLoader类并重写loadClass方法,从而实现自定义的类加载类,但是在JDK1.2之后已不再建议用户去覆盖loadClass()方法,而是建议把自定义的类加载逻辑写在findClass()方法中,从前面的分析可知,findClass()方法是在loadClass()方法中被调用的,当loadClass()方法中父加载器加载失败后,则会调用自己的findClass()方法来完成类加载,这样就可以保证自定义的类加载器也符合双亲委托模式。需要注意的是ClassLoader类中并没有实现findClass()方法的具体代码逻辑,取而代之的是抛出ClassNotFoundException异常,同时应该知道的是findClass方法通常是和defineClass方法一起使用的(稍后会分析),ClassLoader类中findClass()方法源码如下:

      //直接抛出异常
      protected Class<?> findClass(String name) throws ClassNotFoundException {
              throw new ClassNotFoundException(name);
      }
      
    • defineClass(byte[] b, int off, int len)
      defineClass()方法是用来将byte字节流解析成JVM能够识别的Class对象(ClassLoader中已实现该方法逻辑),通过这个方法不仅能够通过class文件实例化class对象,也可以通过其他方式实例化class对象,如通过网络接收一个类的字节码,然后转换为byte字节流创建对应的Class对象,defineClass()方法通常与findClass()方法一起使用,一般情况下,在自定义类加载器时,会直接覆盖ClassLoader的findClass()方法并编写加载规则,取得要加载类的字节码后转换成流,然后调用defineClass()方法生成类的Class对象,简单例子如下:

      protected Class<?> findClass(String name) throws ClassNotFoundException {
      	  // 获取类的字节数组
            byte[] classData = getClassData(name);  
            if (classData == null) {
                throw new ClassNotFoundException();
            } else {
      	      //使用defineClass生成class对象
                return defineClass(name, classData, 0, classData.length);
            }
        }
      

    需要注意的是,如果直接调用defineClass()方法生成类的Class对象,这个类的Class对象并没有解析(也可以理解为链接阶段,毕竟解析是链接的最后一步),其解析操作需要等待初始化阶段进行。

    • resolveClass(Class≺?≻ c)
      使用该方法可以使用类的Class对象创建完成也同时被解析。前面我们说链接阶段主要是对字节码进行验证,为类变量分配内存并设置初始值同时将字节码文件中的符号引用转换为直接引用。

    上述4个方法是ClassLoader类中的比较重要的方法,也是我们可能会经常用到的方法。接看SercureClassLoader扩展了 ClassLoader,新增了几个与使用相关的代码源(对代码源的位置及其证书的验证)和权限定义类验证(主要指对class源码的访问权限)的方法,一般我们不会直接跟这个类打交道,更多是与它的子类URLClassLoader有所关联,前面说过,ClassLoader是一个抽象类,很多方法是空的没有实现,比如 findClass()、findResource()等。而URLClassLoader这个实现类为这些方法提供了具体的实现,并新增了URLClassPath类协助取得Class字节码流等功能,在编写自定义类加载器时,如果没有太过于复杂的需求,可以直接继承URLClassLoader类,这样就可以避免自己去编写findClass()方法及其获取字节码流的方式,使自定义类加载器编写更加简洁,下面是URLClassLoader的类图(利用IDEA生成的类图)

    从类图结构看出URLClassLoader中存在一个URLClassPath类,通过这个类就可以找到要加载的字节码流,也就是说URLClassPath类负责找到要加载的字节码,再读取成字节流,最后通过defineClass()方法创建类的Class对象。从URLClassLoader类的结构图可以看出其构造方法都有一个必须传递的参数URL[],该参数的元素是代表字节码文件的路径,换句话说在创建URLClassLoader对象时必须要指定这个类加载器的到那个目录下找class文件。同时也应该注意URL[]也是URLClassPath类的必传参数,在创建URLClassPath对象时,会根据传递过来的URL数组中的路径判断是文件还是jar包,然后根据不同的路径创建FileLoader或者JarLoader或默认Loader类去加载相应路径下的class文件,而当JVM调用findClass()方法时,就由这3个加载器中的一个将class文件的字节码流加载到内存中,最后利用字节码流创建类的class对象。请记住,如果我们在定义类加载器时选择继承ClassLoader类而非URLClassLoader,必须手动编写findclass()方法的加载逻辑以及获取字节码流的逻辑。了解完URLClassLoader后接着看看剩余的两个类加载器,即拓展类加载器ExtClassLoader和系统类加载器AppClassLoader,这两个类都继承自URLClassLoader,是sun.misc.Launcher的静态内部类。sun.misc.Launcher主要被系统用于启动主应用程序,ExtClassLoader和AppClassLoader都是由sun.misc.Launcher创建的,其类主要类结构如下:

    它们间的关系正如前面所阐述的那样,同时我们发现ExtClassLoader并没有重写loadClass()方法,这足矣说明其遵循双亲委派模式,而AppClassLoader重载了loadCass()方法,但最终调用的还是父类loadClass()方法,因此依然遵守双亲委派模式,重载方法源码如下:

     /**
      * Override loadClass 方法,新增包权限检测功能
      */
     public Class loadClass(String name, boolean resolve)
         throws ClassNotFoundException
     {
         int i = name.lastIndexOf('.');
         if (i != -1) {
             SecurityManager sm = System.getSecurityManager();
             if (sm != null) {
                 sm.checkPackageAccess(name.substring(0, i));
             }
         }
         //依然调用父类的方法
         return (super.loadClass(name, resolve));
     }
    

    其实无论是ExtClassLoader还是AppClassLoader都继承URLClassLoader类,因此它们都遵守双亲委托模型,这点是毋庸置疑的。ok,到此我们对ClassLoader、URLClassLoader、ExtClassLoader、AppClassLoader以及Launcher类间的关系有了比较清晰的了解,同时对一些主要的方法也有一定的认识,这里并没有对这些类的源码进行详细的分析,毕竟没有那个必要,因为我们主要弄得类与类间的关系和常用的方法同时搞清楚双亲委托模式的实现过程,为编写自定义类加载器做铺垫就足够了。ok,前面出现了很多父类加载器的说法,但每个类加载器的父类到底是谁,一直没有阐明,下面我们就通过代码验证的方式来阐明这答案。
    ##类加载器间的关系
    我们进一步了解类加载器间的关系(并非指继承关系),主要可以分为以下4点

    • 启动类加载器,由C++实现,没有父类。

    • 拓展类加载器(ExtClassLoader),由Java语言实现,父类加载器为null

    • 系统类加载器(AppClassLoader),由Java语言实现,父类加载器为ExtClassLoader

    • 自定义类加载器,父类加载器肯定为AppClassLoader。

    下面我们通过程序来验证上述阐述的观点

    /**
     * Created by zejian on 2017/6/18.
     * Blog : http://blog.csdn.net/javazejian [原文地址,请尊重原创]
     */
    //自定义ClassLoader,完整代码稍后分析
    class FileClassLoader extends  ClassLoader{
        private String rootDir;
    
        public FileClassLoader(String rootDir) {
            this.rootDir = rootDir;
        }
        // 编写获取类的字节码并创建class对象的逻辑
        @Override
        protected Class<?> findClass(String name) throws ClassNotFoundException {
           //...省略逻辑代码
        }
    	//编写读取字节流的方法
        private byte[] getClassData(String className) {
            // 读取类文件的字节
            //省略代码....
        }
    }
    
    public class ClassLoaderTest {
    
        public static void main(String[] args) throws ClassNotFoundException {
           
    			 FileClassLoader loader1 = new FileClassLoader(rootDir);
    			
    			  System.out.println("自定义类加载器的父加载器: "+loader1.getParent());
    			  System.out.println("系统默认的AppClassLoader: "+ClassLoader.getSystemClassLoader());
    			  System.out.println("AppClassLoader的父类加载器: "+ClassLoader.getSystemClassLoader().getParent());
    			  System.out.println("ExtClassLoader的父类加载器: "+ClassLoader.getSystemClassLoader().getParent().getParent());
    			
    			/**
    			输出结果:
    			    自定义类加载器的父加载器: sun.misc.Launcher$AppClassLoader@29453f44
    			    系统默认的AppClassLoader: sun.misc.Launcher$AppClassLoader@29453f44
    			    AppClassLoader的父类加载器: sun.misc.Launcher$ExtClassLoader@6f94fa3e
    			    ExtClassLoader的父类加载器: null
    			*/
    
        }
    }
    

    代码中,我们自定义了一个FileClassLoader,这里我们继承了ClassLoader而非URLClassLoader,因此需要自己编写findClass()方法逻辑以及加载字节码的逻辑,关于自定义类加载器我们稍后会分析,这里仅需要知道FileClassLoader是自定义加载器即可,接着在main方法中,通过ClassLoader.getSystemClassLoader()获取到系统默认类加载器,通过获取其父类加载器及其父父类加载器,同时还获取了自定义类加载器的父类加载器,最终输出结果正如我们所预料的,AppClassLoader的父类加载器为ExtClassLoader,而ExtClassLoader没有父类加载器。如果我们实现自己的类加载器,它的父加载器都只会是AppClassLoader。这里我们不妨看看Lancher的构造器源码

    public Launcher() {
            // 首先创建拓展类加载器
            ClassLoader extcl;
            try {
                extcl = ExtClassLoader.getExtClassLoader();
            } catch (IOException e) {
                throw new InternalError(
                    "Could not create extension class loader");
            }
    
            // Now create the class loader to use to launch the application
            try {
    	        //再创建AppClassLoader并把extcl作为父加载器传递给AppClassLoader
                loader = AppClassLoader.getAppClassLoader(extcl);
            } catch (IOException e) {
                throw new InternalError(
                    "Could not create application class loader");
            }
    
            //设置线程上下文类加载器,稍后分析
            Thread.currentThread().setContextClassLoader(loader);
    //省略其他没必要的代码......
            }
        }
    

    显然Lancher初始化时首先会创建ExtClassLoader类加载器,然后再创建AppClassLoader并把ExtClassLoader传递给它作为父类加载器,这里还把AppClassLoader默认设置为线程上下文类加载器,关于线程上下文类加载器稍后会分析。那ExtClassLoader类加载器为什么是null呢?看下面的源码创建过程就明白,在创建ExtClassLoader强制设置了其父加载器为null。

    //Lancher中创建ExtClassLoader
    extcl = ExtClassLoader.getExtClassLoader();
    
    //getExtClassLoader()方法
    public static ExtClassLoader getExtClassLoader() throws IOException{
    
      //........省略其他代码 
      return new ExtClassLoader(dirs);                     
      // .........
    }
    
    //构造方法
    public ExtClassLoader(File[] dirs) throws IOException {
       //调用父类构造URLClassLoader传递null作为parent
       super(getExtURLs(dirs), null, factory);
    }
    
    //URLClassLoader构造
    public URLClassLoader(URL[] urls, ClassLoader parent,
                              URLStreamHandlerFactory factory) {
    

    显然ExtClassLoader的父类为null,而AppClassLoader的父加载器为ExtClassLoader,所有自定义的类加载器其父加载器只会是AppClassLoader,注意这里所指的父类并不是Java继承关系中的那种父子关系。

    #类与类加载器
    ##类与类加载器
    在JVM中表示两个class对象是否为同一个类对象存在两个必要条件

    • 类的完整类名必须一致,包括包名。
    • 加载这个类的ClassLoader(指ClassLoader实例对象)必须相同。

    也就是说,在JVM中,即使这个两个类对象(class对象)来源同一个Class文件,被同一个虚拟机所加载,但只要加载它们的ClassLoader实例对象不同,那么这两个类对象也是不相等的,这是因为不同的ClassLoader实例对象都拥有不同的独立的类名称空间,所以加载的class对象也会存在不同的类名空间中,但前提是覆写loadclass方法,从前面双亲委派模式对loadClass()方法的源码分析中可以知,在方法第一步会通过Class<?> c = findLoadedClass(name);从缓存查找,类名完整名称相同则不会再次被加载,因此我们必须绕过缓存查询才能重新加载class对象。当然也可直接调用findClass()方法,这样也避免从缓存查找,如下

    String rootDir="/Users/zejian/Downloads/Java8_Action/src/main/java/";
    //创建两个不同的自定义类加载器实例
    FileClassLoader loader1 = new FileClassLoader(rootDir);
    FileClassLoader loader2 = new FileClassLoader(rootDir);
    //通过findClass创建类的Class对象
    Class<?> object1=loader1.findClass("com.zejian.classloader.DemoObj");
    Class<?> object2=loader2.findClass("com.zejian.classloader.DemoObj");
    
    System.out.println("findClass->obj1:"+object1.hashCode());
    System.out.println("findClass->obj2:"+object2.hashCode());
    
    /**
      * 直接调用findClass方法输出结果:
      * findClass->obj1:723074861
        findClass->obj2:895328852
        生成不同的实例
      */
    

    如果调用父类的loadClass方法,结果如下,除非重写loadClass()方法去掉缓存查找步骤,不过现在一般都不建议重写loadClass()方法。

    //直接调用父类的loadClass()方法
    Class<?> obj1 =loader1.loadClass("com.zejian.classloader.DemoObj");
    Class<?> obj2 =loader2.loadClass("com.zejian.classloader.DemoObj");
    
    //不同实例对象的自定义类加载器
    System.out.println("loadClass->obj1:"+obj1.hashCode());
    System.out.println("loadClass->obj2:"+obj2.hashCode());
    //系统类加载器
    System.out.println("Class->obj3:"+DemoObj.class.hashCode());
    
    /**
    * 直接调用loadClass方法的输出结果,注意并没有重写loadClass方法
    * loadClass->obj1:1872034366
      loadClass->obj2:1872034366
      Class->    obj3:1872034366
      都是同一个实例
    */
    

    所以如果不从缓存查询相同完全类名的class对象,那么只有ClassLoader的实例对象不同,同一字节码文件创建的class对象自然也不会相同。
    ##了解class文件的显示加载与隐式加载的概念
    所谓class文件的显示加载与隐式加载的方式是指JVM加载class文件到内存的方式,显示加载指的是在代码中通过调用ClassLoader加载class对象,如直接使用Class.forName(name)this.getClass().getClassLoader().loadClass()加载class对象。而隐式加载则是不直接在代码中调用ClassLoader的方法加载class对象,而是通过虚拟机自动加载到内存中,如在加载某个类的class文件时,该类的class文件中引用了另外一个类的对象,此时额外引用的类将通过JVM自动加载到内存中。在日常开发以上两种方式一般会混合使用,这里我们知道有这么回事即可。
    #编写自己的类加载器
    通过前面的分析可知,实现自定义类加载器需要继承ClassLoader或者URLClassLoader,继承ClassLoader则需要自己重写findClass()方法并编写加载逻辑,继承URLClassLoader则可以省去编写findClass()方法以及class文件加载转换成字节码流的代码。那么编写自定义类加载器的意义何在呢?

    • 当class文件不在ClassPath路径下,默认系统类加载器无法找到该class文件,在这种情况下我们需要实现一个自定义的ClassLoader来加载特定路径下的class文件生成class对象。

    • 当一个class文件是通过网络传输并且可能会进行相应的加密操作时,需要先对class文件进行相应的解密后再加载到JVM内存中,这种情况下也需要编写自定义的ClassLoader并实现相应的逻辑。

    • 当需要实现热部署功能时(一个class文件通过不同的类加载器产生不同class对象从而实现热部署功能),需要实现自定义ClassLoader的逻辑。

    ##自定义File类加载器
    这里我们继承ClassLoader实现自定义的特定路径下的文件类加载器并加载编译后DemoObj.class,源码代码如下

    public class DemoObj {
        @Override
        public String toString() {
            return "I am DemoObj";
        }
    }
    
    package com.zejian.classloader;
    
    import java.io.*;
    
    /**
     * Created by zejian on 2017/6/21.
     * Blog : http://blog.csdn.net/javazejian [原文地址,请尊重原创]
     */
    public class FileClassLoader extends ClassLoader {
        private String rootDir;
    
        public FileClassLoader(String rootDir) {
            this.rootDir = rootDir;
        }
    
        /**
         * 编写findClass方法的逻辑
         * @param name
         * @return
         * @throws ClassNotFoundException
         */
        @Override
        protected Class<?> findClass(String name) throws ClassNotFoundException {
            // 获取类的class文件字节数组
            byte[] classData = getClassData(name);
            if (classData == null) {
                throw new ClassNotFoundException();
            } else {
                //直接生成class对象
                return defineClass(name, classData, 0, classData.length);
            }
        }
    
        /**
         * 编写获取class文件并转换为字节码流的逻辑
         * @param className
         * @return
         */
        private byte[] getClassData(String className) {
            // 读取类文件的字节
            String path = classNameToPath(className);
            try {
                InputStream ins = new FileInputStream(path);
                ByteArrayOutputStream baos = new ByteArrayOutputStream();
                int bufferSize = 4096;
                byte[] buffer = new byte[bufferSize];
                int bytesNumRead = 0;
                // 读取类文件的字节码
                while ((bytesNumRead = ins.read(buffer)) != -1) {
                    baos.write(buffer, 0, bytesNumRead);
                }
                return baos.toByteArray();
            } catch (IOException e) {
                e.printStackTrace();
            }
            return null;
        }
    
        /**
         * 类文件的完全路径
         * @param className
         * @return
         */
        private String classNameToPath(String className) {
            return rootDir + File.separatorChar
                    + className.replace('.', File.separatorChar) + ".class";
        }
    
        public static void main(String[] args) throws ClassNotFoundException {
            String rootDir="/Users/zejian/Downloads/Java8_Action/src/main/java/";
            //创建自定义文件类加载器
            FileClassLoader loader = new FileClassLoader(rootDir);
    
            try {
                //加载指定的class文件
                Class<?> object1=loader.loadClass("com.zejian.classloader.DemoObj");
                System.out.println(object1.newInstance().toString());
              
                //输出结果:I am DemoObj
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
    
    

    显然我们通过getClassData()方法找到class文件并转换为字节流,并重写findClass()方法,利用defineClass()方法创建了类的class对象。在main方法中调用了loadClass()方法加载指定路径下的class文件,由于启动类加载器、拓展类加载器以及系统类加载器都无法在其路径下找到该类,因此最终将有自定义类加载器加载,即调用findClass()方法进行加载。如果继承URLClassLoader实现,那代码就更简洁了,如下:

    /**
     * Created by zejian on 2017/6/21.
     * Blog : http://blog.csdn.net/javazejian [原文地址,请尊重原创]
     */
    public class FileUrlClassLoader extends URLClassLoader {
    
        public FileUrlClassLoader(URL[] urls, ClassLoader parent) {
            super(urls, parent);
        }
    
        public FileUrlClassLoader(URL[] urls) {
            super(urls);
        }
    
        public FileUrlClassLoader(URL[] urls, ClassLoader parent, URLStreamHandlerFactory factory) {
            super(urls, parent, factory);
        }
    
    
        public static void main(String[] args) throws ClassNotFoundException, MalformedURLException {
            String rootDir="/Users/zejian/Downloads/Java8_Action/src/main/java/";
            //创建自定义文件类加载器
            File file = new File(rootDir);
            //File to URI
            URI uri=file.toURI();
            URL[] urls={uri.toURL()};
    
            FileUrlClassLoader loader = new FileUrlClassLoader(urls);
    
            try {
                //加载指定的class文件
                Class<?> object1=loader.loadClass("com.zejian.classloader.DemoObj");
                System.out.println(object1.newInstance().toString());
              
                //输出结果:I am DemoObj
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
    

    非常简洁除了需要重写构造器外无需编写findClass()方法及其class文件的字节流转换逻辑。
    ##自定义网络类加载器
    自定义网络类加载器,主要用于读取通过网络传递的class文件(在这里我们省略class文件的解密过程),并将其转换成字节流生成对应的class对象,如下

    /**
     * Created by zejian on 2017/6/21.
     * Blog : http://blog.csdn.net/javazejian [原文地址,请尊重原创]
     */
    public class NetClassLoader extends ClassLoader {
    
        private String url;//class文件的URL
    
        public NetClassLoader(String url) {
            this.url = url;
        }
    
        @Override
        protected Class<?> findClass(String name) throws ClassNotFoundException {
            byte[] classData = getClassDataFromNet(name);
            if (classData == null) {
                throw new ClassNotFoundException();
            } else {
                return defineClass(name, classData, 0, classData.length);
            }
        }
    
        /**
         * 从网络获取class文件
         * @param className
         * @return
         */
        private byte[] getClassDataFromNet(String className) {
            String path = classNameToPath(className);
            try {
                URL url = new URL(path);
                InputStream ins = url.openStream();
                ByteArrayOutputStream baos = new ByteArrayOutputStream();
                int bufferSize = 4096;
                byte[] buffer = new byte[bufferSize];
                int bytesNumRead = 0;
                // 读取类文件的字节
                while ((bytesNumRead = ins.read(buffer)) != -1) {
                    baos.write(buffer, 0, bytesNumRead);
                }
                //这里省略解密的过程.......
                return baos.toByteArray();
            } catch (Exception e) {
                e.printStackTrace();
            }
            return null;
        }
    
        private String classNameToPath(String className) {
            // 得到类文件的URL
            return url + "/" + className.replace('.', '/') + ".class";
        }
    
    }
    

    比较简单,主要是在获取字节码流时的区别,从网络直接获取到字节流再转车字节数组然后利用defineClass方法创建class对象,如果继承URLClassLoader类则和前面文件路径的实现是类似的,无需担心路径是filePath还是Url,因为URLClassLoader内的URLClassPath对象会根据传递过来的URL数组中的路径判断是文件还是jar包,然后根据不同的路径创建FileLoader或者JarLoader或默认类Loader去读取对于的路径或者url下的class文件。
    ##热部署类加载器
    所谓的热部署就是利用同一个class文件不同的类加载器在内存创建出两个不同的class对象(关于这点的原因前面已分析过,即利用不同的类加载实例),由于JVM在加载类之前会检测请求的类是否已加载过(即在loadClass()方法中调用findLoadedClass()方法),如果被加载过,则直接从缓存获取,不会重新加载。注意同一个类加载器的实例和同一个class文件只能被加载器一次,多次加载将报错,因此我们实现的热部署必须让同一个class文件可以根据不同的类加载器重复加载,以实现所谓的热部署。实际上前面的实现的FileClassLoader和FileUrlClassLoader已具备这个功能,但前提是直接调用findClass()方法,而不是调用loadClass()方法,因为ClassLoader中loadClass()方法体中调用findLoadedClass()方法进行了检测是否已被加载,因此我们直接调用findClass()方法就可以绕过这个问题,当然也可以重新loadClass方法,但强烈不建议这么干。利用FileClassLoader类测试代码如下:

     public static void main(String[] args) throws ClassNotFoundException {
            String rootDir="/Users/zejian/Downloads/Java8_Action/src/main/java/";
            //创建自定义文件类加载器
            FileClassLoader loader = new FileClassLoader(rootDir);
            FileClassLoader loader2 = new FileClassLoader(rootDir);
    
            try {
                //加载指定的class文件,调用loadClass()
                Class<?> object1=loader.loadClass("com.zejian.classloader.DemoObj");
                Class<?> object2=loader2.loadClass("com.zejian.classloader.DemoObj");
    
                System.out.println("loadClass->obj1:"+object1.hashCode());
                System.out.println("loadClass->obj2:"+object2.hashCode());
    
                //加载指定的class文件,直接调用findClass(),绕过检测机制,创建不同class对象。
                Class<?> object3=loader.findClass("com.zejian.classloader.DemoObj");
                Class<?> object4=loader2.findClass("com.zejian.classloader.DemoObj");
    
                System.out.println("loadClass->obj3:"+object3.hashCode());
                System.out.println("loadClass->obj4:"+object4.hashCode());
    
                /**
                 * 输出结果:
                 * loadClass->obj1:644117698
                   loadClass->obj2:644117698
                   findClass->obj3:723074861
                   findClass->obj4:895328852
                 */
    
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    

    #双亲委派模型的破坏者-线程上下文类加载器

        在Java应用中存在着很多服务提供者接口(Service Provider Interface,SPI),这些接口允许第三方为它们提供实现,如常见的 SPI 有 JDBC、JNDI等,这些 SPI 的接口属于 Java 核心库,一般存在rt.jar包中,由Bootstrap类加载器加载,而 SPI 的第三方实现代码则是作为Java应用所依赖的 jar 包被存放在classpath路径下,由于SPI接口中的代码经常需要加载具体的第三方实现类并调用其相关方法,但SPI的核心接口类是由引导类加载器来加载的,而Bootstrap类加载器无法直接加载SPI的实现类,同时由于双亲委派模式的存在,Bootstrap类加载器也无法反向委托AppClassLoader加载器SPI的实现类。在这种情况下,我们就需要一种特殊的类加载器来加载第三方的类库,而线程上下文类加载器就是很好的选择。
        线程上下文类加载器(contextClassLoader)是从 JDK 1.2 开始引入的,我们可以通过java.lang.Thread类中的getContextClassLoader()setContextClassLoader(ClassLoader cl)方法来获取和设置线程的上下文类加载器。如果没有手动设置上下文类加载器,线程将继承其父线程的上下文类加载器,初始线程的上下文类加载器是系统类加载器(AppClassLoader),在线程中运行的代码可以通过此类加载器来加载类和资源,如下图所示,以jdbc.jar加载为例

    从图可知rt.jar核心包是有Bootstrap类加载器加载的,其内包含SPI核心接口类,由于SPI中的类经常需要调用外部实现类的方法,而jdbc.jar包含外部实现类(jdbc.jar存在于classpath路径)无法通过Bootstrap类加载器加载,因此只能委派线程上下文类加载器把jdbc.jar中的实现类加载到内存以便SPI相关类使用。显然这种线程上下文类加载器的加载方式破坏了“双亲委派模型”,它在执行过程中抛弃双亲委派加载链模式,使程序可以逆向使用类加载器,当然这也使得Java类加载器变得更加灵活。为了进一步证实这种场景,不妨看看DriverManager类的源码,DriverManager是Java核心rt.jar包中的类,该类用来管理不同数据库的实现驱动即Driver,它们都实现了Java核心包中的java.sql.Driver接口,如mysql驱动包中的com.mysql.jdbc.Driver,这里主要看看如何加载外部实现类,在DriverManager初始化时会执行如下代码

    //DriverManager是Java核心包rt.jar的类
    public class DriverManager {
    	//省略不必要的代码
        static {
            loadInitialDrivers();//执行该方法
            println("JDBC DriverManager initialized");
        }
    
    //loadInitialDrivers方法
     private static void loadInitialDrivers() {
         sun.misc.Providers()
         AccessController.doPrivileged(new PrivilegedAction<Void>() {
                public Void run() {
    				//加载外部的Driver的实现类
                    ServiceLoader<Driver> loadedDrivers = ServiceLoader.load(Driver.class);
                  //省略不必要的代码......
                }
            });
        }
    

    在DriverManager类初始化时执行了loadInitialDrivers()方法,在该方法中通过ServiceLoader.load(Driver.class);去加载外部实现的驱动类,ServiceLoader类会去读取mysql的jdbc.jar下META-INF文件的内容,如下所示

    而com.mysql.jdbc.Driver继承类如下:

    public class Driver extends com.mysql.cj.jdbc.Driver {
        public Driver() throws SQLException {
            super();
        }
    
        static {
            System.err.println("Loading class `com.mysql.jdbc.Driver'. This is deprecated. The new driver class is `com.mysql.cj.jdbc.Driver'. "
                    + "The driver is automatically registered via the SPI and manual loading of the driver class is generally unnecessary.");
        }
    }
    

    从注释可以看出平常我们使用com.mysql.jdbc.Driver已被丢弃了,取而代之的是com.mysql.cj.jdbc.Driver,也就是说官方不再建议我们使用如下代码注册mysql驱动

    //不建议使用该方式注册驱动类
    Class.forName("com.mysql.jdbc.Driver");
    String url = "jdbc:mysql://localhost:3306/cm-storylocker?characterEncoding=UTF-8";
    // 通过java库获取数据库连接
    Connection conn = java.sql.DriverManager.getConnection(url, "root", "root@555");
          
    

    而是直接去掉注册步骤,如下即可

    String url = "jdbc:mysql://localhost:3306/cm-storylocker?characterEncoding=UTF-8";
    // 通过java库获取数据库连接
    Connection conn = java.sql.DriverManager.getConnection(url, "root", "root@555");
          
    

    这样ServiceLoader会帮助我们处理一切,并最终通过load()方法加载,看看load()方法实现

    public static <S> ServiceLoader<S> load(Class<S> service) {
    	 //通过线程上下文类加载器加载
          ClassLoader cl = Thread.currentThread().getContextClassLoader();
          return ServiceLoader.load(service, cl);
      }
    

    很明显了确实通过线程上下文类加载器加载的,实际上核心包的SPI类对外部实现类的加载都是基于线程上下文类加载器执行的,通过这种方式实现了Java核心代码内部去调用外部实现类。我们知道线程上下文类加载器默认情况下就是AppClassLoader,那为什么不直接通过getSystemClassLoader()获取类加载器来加载classpath路径下的类的呢?其实是可行的,但这种直接使用getSystemClassLoader()方法获取AppClassLoader加载类有一个缺点,那就是代码部署到不同服务时会出现问题,如把代码部署到Java Web应用服务或者EJB之类的服务将会出问题,因为这些服务使用的线程上下文类加载器并非AppClassLoader,而是Java Web应用服自家的类加载器,类加载器不同。,所以我们应用该少用getSystemClassLoader()。总之不同的服务使用的可能默认ClassLoader是不同的,但使用线程上下文类加载器总能获取到与当前程序执行相同的ClassLoader,从而避免不必要的问题。ok~.关于线程上下文类加载器暂且聊到这,前面阐述的DriverManager类,大家可以自行看看源码,相信会有更多的体会,另外关于ServiceLoader本篇并没有过多的阐述,毕竟我们主题是类加载器,但ServiceLoader是个很不错的解耦机制,大家可以自行查阅其相关用法。

    ok~,本篇到此告一段落,如有误处,欢迎留言,谢谢。

    参考资料:
    http://blog.csdn.net/yangcheng33/article/details/52631940
    http://ifeve.com/wp-content/uploads/2014/03/JSR133中文版1.pdf

    《深入理解JVM虚拟机》
    《深入分析Java Web 技术内幕》

    展开全文
  • Java规则数组

    千次阅读 2019-06-18 14:55:21
    就我们常见的Java数组与其他程序设计语言中提供的数组...正是因为Java数组的特征,所以在Java数组中可以创建一个“不规则”数组,即数组的每一行有不同的长度,例如第一行有一列,第二行有两列,依次推。数组如下...

    就我们常见的Java数组与其他程序设计语言中提供的数组没有多大区别,但实际上存在着一些细微的差异,而这正是Java的优势所在,Java实际上没有多维数组,只有一维数组。多维数组被称为“数组的数组”。

    二位数组在内部的存储结构图如下所示:

    正是因为Java数组的特征,所以在Java数组中可以创建一个“不规则”数组,即数组的每一行有不同的长度,例如第一行有一列,第二行有两列,依次类推。数组如下图所示:

    创建不规则数组代码如下:

    
    public class Main {
    
        public static void main(String args[]) {
            final int MAX = 10;
            int [][] arrs = new int[MAX + 1][];     //分配一个具有所含行数的数组
            for (int n = 0; n <= MAX; n++)          //分配每一行
                arrs[n] = new int[n + 1];
    
            //给数组赋值
            for (int n = 0; n < arrs.length; n++)
                for (int k = 0; k < arrs[n].length; k++){
                    int lotteryArrs = 1;
                    arrs[n][k] = lotteryArrs;
                }
    
            //遍历数组
            for (int[] row : arrs){
                for (int arr : row)
                    System.out.print(arr + " ");
                System.out.println();
            }
        }
    }

     

    展开全文
  • Java各种规则引擎

    万次阅读 2019-08-21 10:15:14
    Drools 规则是在 Java 应用程序上运行的,其要执行的步骤顺序由代码确定 ,为了实现这一点,Drools 规则引擎将业务规则转换成执行树。 特性: 优点:  1、简化系统架构,优化应用  2、提高系统的可维护性和...

    一. Drools规则引擎

    简介:

    Drools就是为了解决业务代码和业务规则分离的引擎。
    Drools 规则是在 Java 应用程序上运行的,其要执行的步骤顺序由代码确定
    ,为了实现这一点,Drools 规则引擎将业务规则转换成执行树。
    

    特性:

    优点:
       1、简化系统架构,优化应用
       2、提高系统的可维护性和维护成本
       3、方便系统的整合
       4、减少编写“硬代码”业务规则的成本和风险
    

    原理:

    使用方式:

    (1)Maven 依赖:

    <dependencies>
        <dependency>
            <groupId>org.kie</groupId>
            <artifactId>kie-api</artifactId>
            <version>6.5.0.Final</version>
        </dependency>
        <dependency>
            <groupId>org.drools</groupId>
            <artifactId>drools-compiler</artifactId>
            <version>6.5.0.Final</version>
            <scope>runtime</scope>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
        </dependency>
    </dependencies>
    

    (2)新建配置文件/src/resources/META-INF/kmodule.xml

    <?xml version="1.0" encoding="UTF-8"?>
    <kmodule xmlns="http://jboss.org/kie/6.0.0/kmodule">
        <kbase name="rules" packages="rules">
            <ksession name="myAgeSession"/>
        </kbase>
    </kmodule>
    

    (3)新建drools规则文件/src/resources/rules/age.drl

    import cn.caijiajia.decision.domain.User               // 导入类
    
    dialect  "mvel"
    
    rule "age"                                      // 规则名,唯一
        when
            $user : User(age<15 || age>60)     //规则的条件部分
        then
            System.out.println("年龄不符合要求!");
    end
    

    工程搭建完毕,效果如图:

    测试用例:

    package cn.caijiajia.decision.service;
    
    import cn.caijiajia.decision.domain.User;
    import org.junit.Test;
    import org.junit.runner.RunWith;
    import org.kie.api.KieServices;
    import org.kie.api.runtime.KieContainer;
    import org.kie.api.runtime.KieSession;
    import org.springframework.test.context.ContextConfiguration;
    import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
    
    /**
     * CreateBy: Liurenquan
     * CreateDate: 2018/12/26
     */
    @RunWith(SpringJUnit4ClassRunner.class)
    @ContextConfiguration(locations = {"classpath*:applicationContext.xml"})
    public class TestUser {
    
        private static KieContainer container = null;
        private KieSession statefulKieSession = null;
    
        @Test
        public void test(){
            KieServices kieServices = KieServices.Factory.get();
            container = kieServices.getKieClasspathContainer();
            statefulKieSession = container.newKieSession("myAgeSession");
            User user = new User("duval yang",12);
            statefulKieSession.insert(user);
            statefulKieSession.fireAllRules();
            statefulKieSession.dispose();
    
        }
    
    
    
    }
    
    

    二.Aviator表达式求值引擎

    简介:

    Aviator是一个高性能、轻量级的java语言实现的表达式求值引擎,主要用于各
    种表达式的动态求值。现在已经有很多开源可用的java表达式求值引擎,为什
    么还需要Avaitor呢?
    
    Aviator的设计目标是轻量级和高性能 ,相比于Groovy、JRuby的笨重,Aviator
    非常小,加上依赖包也才450K,不算依赖包的话只有70K;当然,Aviator的语法
    是受限的,它不是一门完整的语言,而只是语言的一小部分集合。
    
    其次,Aviator的实现思路与其他轻量级的求值器很不相同,其他求值器一般都
    是通过解释的方式运行,而Aviator则是直接将表达式编译成Java字节码,交给
    JVM去执行。简单来说,Aviator的定位是介于Groovy这样的重量级脚本语言和
    IKExpression这样的轻量级表达式引擎之间。
    

    特性:

    (1)支持大部分运算操作符,包括算术操作符、关系运算符、逻辑操作符、
    正则匹配操作符(=~)、三元表达式?: ,并且支持操作符的优先级和括号强制优
    先级,具体请看后面的操作符列表。
    (2)支持函数调用和自定义函数。
    (3)支持正则表达式匹配,类似Ruby、Perl的匹配语法,并且支持类Ruby的
    $digit指向匹配分组。自动类型转换,当执行操作的时候,会自动判断操作数类
    型并做相应转换,无法转换即抛异常。
    (4)支持传入变量,支持类似a.b.c的嵌套变量访问。
    (5)性能优秀。
    (6)Aviator的限制,没有if else、do while等语句,没有赋值语句,仅支持逻
    辑表达式、算术表达式、三元表达式和正则匹配。没有位运算符
    
    

    整体结构:

    maven依赖:

    <dependency>
        <groupId>com.googlecode.aviator</groupId>
        <artifactId>aviator</artifactId>
        <version>${aviator.version}</version>
    </dependency>
    

    执行方式

    执行表达式的方法有两个:execute()、exec();
    execute(),需要传递Map格式参数
    exec(),不需要传递Map

    示例:

    package cn.caijiajia.decision.controller;
    
    import com.googlecode.aviator.AviatorEvaluator;
    import java.util.HashMap;
    import java.util.Map;
    
    /**
     * CreateBy: Liurenquan
     * CreateDate: 2018/12/25
     */
    public class Test {
        public static void main(String[] args) {
            // exec执行方式,无需传递Map格式
            String age = "18";
            System.out.println(AviatorEvaluator.exec("'His age is '+ age +'!'", age));
    
    
    
            // execute执行方式,需传递Map格式
            Map<String, Object> map = new HashMap<String, Object>();
            map.put("age", "18");
            System.out.println(AviatorEvaluator.execute("'His age is '+ age +'!'", 
    map));
    
        }
    }
    

    使用函数

    Aviator可以使用两种函数:内置函数、自定义函数
    (1)内置函数

    package cn.caijiajia.decision.service;
    
    import com.googlecode.aviator.AviatorEvaluator;
    
    import java.util.HashMap;
    import java.util.Map;
    
    /**
     * CreateBy: Liurenquan
     * CreateDate: 2018/12/25
     */
    public class Test {
        public static void main(String[] args) {
            Map<String,Object> map = new HashMap<>();
            map.put("s1","123qwer");
            map.put("s2","123");
    
      System.out.println(AviatorEvaluator.execute("string.startsWith(s1,s2)",map));
    
        }
    }
    
    
    

    (2)自定义函数

    自定义函数要继承AbstractFunction类,重写目标方法。

    
    package cn.caijiajia.decision.controller;
    
    import com.googlecode.aviator.AviatorEvaluator;
    import com.googlecode.aviator.runtime.function.AbstractFunction;
    import com.googlecode.aviator.runtime.function.FunctionUtils;
    import com.googlecode.aviator.runtime.type.AviatorDouble;
    import com.googlecode.aviator.runtime.type.AviatorLong;
    import com.googlecode.aviator.runtime.type.AviatorObject;
    
    import java.util.HashMap;
    import java.util.Map;
    
    /**
     * CreateBy: Liurenquan
     * CreateDate: 2018/12/25
     */
    public class Test {
        public static void main(String[] args) {
            // 注册自定义函数
            AviatorEvaluator.addFunction(new MultiplyFunction());
            // 方式1
            System.out.println(AviatorEvaluator.execute("multiply(12.23, -2.3)"));
            // 方式2
            Map<String, Object> params = new HashMap<>();
            params.put("a", 12.23);
            params.put("b", -2.3);
            System.out.println(AviatorEvaluator.execute("multiply(a, b)", params));
        }
    
    }
    
    class MultiplyFunction extends AbstractFunction{
        @Override
        public AviatorObject call(Map<String, Object> env, AviatorObject arg1, AviatorObject arg2) {
    
            double num1 = FunctionUtils.getNumberValue(arg1, env).doubleValue();
            double num2 = FunctionUtils.getNumberValue(arg2, env).doubleValue();
            return new AviatorDouble(num1 * num2);
        }
    
        @Override
        public String getName() {
            return "multiply";
        }
    
    }
    

    常用操作符的使用

    (1)操作符列表

    (2)常量和变量

    (3)编译表达式

    package cn.caijiajia.decision.service;
    
    import com.googlecode.aviator.AviatorEvaluator;
    import com.googlecode.aviator.Expression;
    
    import java.util.HashMap;
    import java.util.Map;
    
    /**
    * CreateBy: Liurenquan
    * CreateDate: 2018/12/25
    */
    public class Test {
       public static void main(String[] args) {
           String expression = "a+(b-c)>100";
           // 编译表达式
           Expression compiledExp = AviatorEvaluator.compile(expression);
    
           Map<String, Object> env = new HashMap<>();
           env.put("a", 100.3);
           env.put("b", 45);
           env.put("c", -199.100);
    
           // 执行表达式
           Boolean result = (Boolean) compiledExp.execute(env);
           System.out.println(result);
    
       }
    }
    
    

    (4) 访问数组和集合
    List和数组用list[0]和array[0],Map用map.date

    package cn.caijiajia.decision.service;
    
    import com.googlecode.aviator.AviatorEvaluator;
    import com.googlecode.aviator.Expression;
    
    import java.util.*;
    
    /**
     * CreateBy: Liurenquan
     * CreateDate: 2018/12/25
     */
    public class Test {
        public static void main(String[] args) {
    
            final List<String> list = new ArrayList<>();
            list.add("hello");
            list.add(" world");
    
            final int[] array = new int[3];
            array[0] = 0;
            array[1] = 1;
            array[2] = 3;
    
            final Map<String, Date> map = new HashMap<>();
            map.put("date", new Date());
    
            Map<String, Object> env = new HashMap<>();
            env.put("list", list);
            env.put("array", array);
            env.put("map", map);
    
            System.out.println(AviatorEvaluator.execute(
                    "list[0]+':'+array[0]+':'+'today is '+map.date", env));
    
        }
    
    }
    

    (5) 三元比较符

    package cn.caijiajia.decision.controller;
    
    import com.googlecode.aviator.AviatorEvaluator;
    
    import java.util.HashMap;
    import java.util.Map;
    
    /**
     * CreateBy: Liurenquan
     * CreateDate: 2018/12/25
     */
    public class Test {
        public static void main(String[] args) {
    
            Map<String, Object> env = new HashMap<String, Object>();
            env.put("a", -5);
            String result = (String) AviatorEvaluator.execute("a>0? 'yes':'no'", env);
            System.out.println(result);
        }
    
    }
    

    (6) 正则表达式匹配

    package cn.caijiajia.decision.controller;
    
    import com.googlecode.aviator.AviatorEvaluator;
    
    import java.text.SimpleDateFormat;
    import java.util.Date;
    import java.util.HashMap;
    import java.util.Map;
    
    /**
     * CreateBy: Liurenquan
     * CreateDate: 2018/12/25
     */
    public class Test {
        public static void main(String[] args) {
            String email = "hello2018@gmail.com";
            Map<String, Object> env = new HashMap<String, Object>();
            env.put("email", email);
            String username = (String) AviatorEvaluator.execute("email=~/([\\w0-8]+)@\\w+[\\.\\w+]+/ ? $1 : 'unknow' ", env);
            System.out.println(username);
        }
    }
    

    (7) 变量的语法糖衣

    
    package cn.caijiajia.decision.controller;
    
    import com.googlecode.aviator.AviatorEvaluator;
    
    import java.util.HashMap;
    import java.util.Map;
    
    /**
     * CreateBy: Liurenquan
     * CreateDate: 2018/12/25
     */
    public class Test {
        public static void main(String[] args) {
            User user = new User(1,"jack","18");
            Map<String, Object> env = new HashMap<>();
            env.put("user", user);
    
            String result = (String) AviatorEvaluator.execute(" '[user id='+ user.id + ',name='+user.name + ',age=' +user.age +']' ", env);
            System.out.println(result);
        }
    }
    
    
    
    package cn.caijiajia.decision.controller;
    
    /**
     * CreateBy: Liurenquan
     * CreateDate: 2018/12/25
     */
    public class User {
    
        private int id;
    
        private String name;
    
        private String age;
    
        public User() {
        }
    
        public User(int id, String name, String age) {
            this.id = id;
            this.name = name;
            this.age = age;
        }
    
        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 String getAge() {
            return age;
        }
    
        public void setAge(String age) {
            this.age = age;
        }
    
        @Override
        public String toString() {
            return "User{" +
                    "id=" + id +
                    ", name='" + name + '\'' +
                    ", age='" + age + '\'' +
                    '}';
        }
    
    }
    

    (8) nil对象[任何对象都比nil大除了nil本身]

    nil是Aviator内置的常量,类似java中的null,表示空的值。nil跟null不同的在
    于,在java中null只能使用在==、!=的比较运算符,而nil还可以使用>、>=、
    <、<=等比较运算符。Aviator规定,[任何对象都比nil大除了nil本身]。用户传入
    的变量如果为null,将自动以nil替代。
    
            AviatorEvaluator.execute("nil == nil");  //true 
            AviatorEvaluator.execute(" 3> nil");    //true 
            AviatorEvaluator.execute(" true!= nil");    //true 
            AviatorEvaluator.execute(" ' '>nil ");  //true 
            AviatorEvaluator.execute(" a==nil ");   //true,a is null
    nil与String相加的时候,跟java一样显示为null
    
    

    (9) 日期比较

    package cn.caijiajia.decision.controller;
    
    import com.googlecode.aviator.AviatorEvaluator;
    
    import java.text.SimpleDateFormat;
    import java.util.Date;
    import java.util.HashMap;
    import java.util.Map;
    
    /**
     * CreateBy: Liurenquan
     * CreateDate: 2018/12/25
     */
    public class Test {
        public static void main(String[] args) {
            Map<String, Object> env = new HashMap<String, Object>();
            final Date date = new Date();
            String dateStr = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss:SS").format(date);
            env.put("date", date);
            env.put("dateStr", dateStr);
    
            Boolean result = (Boolean) AviatorEvaluator.execute("date==dateStr",
     env);
            System.out.println(result);
    
            result = (Boolean) AviatorEvaluator.execute("date > '2009-12-20 
    00:00:00:00' ", env);
            System.out.println(result);
    
            result = (Boolean) AviatorEvaluator.execute("date < '2200-12-20 
    00:00:00:00' ", env);
            System.out.println(result);
    
            result = (Boolean) AviatorEvaluator.execute("date ==date ", env);
            System.out.println(result);
    
    
        }
    }
    

    (10) 语法手册

    数据类型

    • Number类型:数字类型,支持两种类型,分别对应Java的Long和Double,也就是说任何整数都将被转换为Long,而任何浮点数都将被转换为Double,包括用户传入的数值也是如此转换。不支持科学计数法,仅支持十进制。如-1、100、2.3等。

    • String类型: 字符串类型,单引号或者双引号括起来的文本串,如'hello world',变量如果传入的是String或者Character也将转为String类型。

    • Bool类型: 常量true和false,表示真值和假值,与java的Boolean.TRUE和Boolean.False对应。

    • Pattern类型: 类似Ruby、perl的正则表达式,以//括起来的字符串,如//d+/,内部实现为java.util.Pattern。

    • 变量类型: 与Java的变量命名规则相同,变量的值由用户传入,如"a"、"b"等

    • nil类型: 常量nil,类似java中的null,但是nil比较特殊,nil不仅可以参与==、!=的比较,也可以参与>、>=、<、<=的比较,Aviator规定任何类型都n大于nil除了nil本身,nil==nil返回true。用户传入的变量值如果为null,那么也将作为nil处理,nil打印为null。

    算术运算符

    Aviator支持常见的算术运算符,包括+ - <tt></tt> / % 五个二元运算符,和一元运算符"-"。其中 - <tt></tt> / %和一元的"-"仅能作用于Number类型。

    "+"不仅能用于Number类型,还可以用于String的相加,或者字符串与其他对象的相加。Aviator规定,任何类型与String相加,结果为String。

    逻辑运算符

    Avaitor的支持的逻辑运算符包括,一元否定运算符"!",以及逻辑与的"&&",逻辑或的"||"。逻辑运算符的操作数只能为Boolean。

    关系运算符

    Aviator支持的关系运算符包括"<" "<=" ">" ">=" 以及"=="和"!=" 。
    &&和||都执行短路规则。

    关系运算符可以作用于Number之间、String之间、Pattern之间、Boolean之间、变量之间以及其他类型与nil之间的关系比较,不同类型除了nil之外不能相互比较。

    Aviator规定任何对象都比nil大除了nil之外。

    匹配运算符

    匹配运算符"=~"用于String和Pattern的匹配,它的左操作数必须为String,右操作数必须为Pattern。匹配成功后,Pattern的分组将存于变量$num,num为分组索引。

    三元运算符

    Aviator没有提供if else语句,但是提供了三元运算符 "?:",形式为 bool ? exp1: exp2。 其中bool必须为结果为Boolean类型的表达式,而exp1和exp2可以为任何合法的Aviator表达式,并且不要求exp1和exp2返回的结果类型一致。

    两种模式
    默认AviatorEvaluator以编译速度优先:
    AviatorEvaluator.setOptimize(AviatorEvaluator.COMPILE);
    你可以修改为运行速度优先,这会做更多的编译优化:
    AviatorEvaluator.setOptimize(AviatorEvaluator.EVAL);

    三.MVEL表达式解析器

    简介:

    MVEL在很大程度上受到Java语法的启发,作为一个表达式语言,也有一些根本
    的区别,旨在更高的效率,例如:直接支持集合、数组和字符串匹配等操作以
    及正则表达式。 MVEL用于执行使用Java语法编写的表达式。
    

    特性:

    MVEL是一个功能强大的基于Java应用程序的表达式语言。
    目前最新的版本是2.0,具有以下特性:
    (1). 动态JIT优化器。当负载超过一个确保代码产生的阈值时,选择性地产生字
    节代码,这大大减少了内存的使用量。新的静态类型检查和属性支持,允许集成
    类型安全表达。
    (2). 错误报告的改善。包括行和列的错误信息。
    (3). 新的脚本语言特征。MVEL2.0 包含函数定义,如:闭包,lambda定义,
    标准循环构造(for, while, do-while, do-until…),空值安全导航操作,内联with
    -context运营 ,易变的(isdef)的测试运营等等。
    (4). 改进的集成功能。迎合主流的需求,MVEL2.0支持基础类型的个性化属性处理器,集成到JIT中。
    (5). 更快的模板引擎,支持线性模板定义,宏定义和个性化标记定义。
    (6). 新的交互式shell(MVELSH)。
    
    (7). 缺少可选类型安全
    (8). 集成不良,通常通过映射填入内容。没有字节码不能运作用字节码生成编
    译时间慢,还增加了可扩展性问题;不用字节码生成运行时执行非常慢
    (9). 内存消耗过大
    (10). Jar巨大/依赖规模
    

    原理:

    与java不同,MVEL是动态类型(带有可选分类),也就是说在源文件中是没有
    类型限制的。一条MVEL表达式,简单的可以是单个标识符,复杂的则可能是
    一个充满了方法调用和内部集合创建的庞大的布尔表达式。
    

    使用方式:

    maven引入jar:

    <dependency>
        <groupId>org.mvel</groupId>
        <artifactId>mvel2</artifactId>
        <version>2.3.1.Final</version>
    </dependency>
    
    

    测试:

    package com.lrq.wechatdemo.utils;
    
    import com.google.common.collect.Maps;
    import org.mvel2.MVEL;
    
    import java.util.Map;
    
    /**
     * CreateBy: Liurenquan
     * CreateDate: 2018/12/26
     */
    public class MvelUtils {
    
        public static void main(String[] args) {
            String expression = "a == null && b == nil ";
            Map<String,Object> map = Maps.newHashMap();
            map.put("a",null);
            map.put("b",null);
    
            Object object = MVEL.eval(expression,map);
            System.out.println(object);
        }
    
    }
    

    四.EasyRules规则引擎

    简介:

    easy-rules首先集成了mvel表达式,后续可能集成SpEL的一款轻量
    级规则引擎
    

    特性:

    easy rules是一个简单而强大的java规则引擎,它有以下特性:
    
    轻量级框架,学习成本低
    基于POJO
    为定义业务引擎提供有用的抽象和简便的应用
    从原始的规则组合成复杂的规则
    它主要包括几个主要的类或接口:Rule,RulesEngine,RuleListener,Facts 
    还有几个主要的注解:@Action,@Condition,@Fact,@Priority,@Rule
    

    使用方式:

    @Rule可以标注name和description属性,每个rule的name要唯一,
    如果没有指定,则RuleProxy则默认取类名
    @Condition是条件判断,要求返回boolean值,表示是否满足条件
    
    @Action标注条件成立之后触发的方法
    
    @Priority标注该rule的优先级,默认是Integer.MAX_VALUE - 1,值
    越小越优先
    
    @Fact 我们要注意Facts的使用。Facts的用法很像Map,它是客户
    端和规则文件之间通信的桥梁。在客户端使用put方法向Facts中添
    加数据,在规则文件中通过key来得到相应的数据。
    

    有两种使用方式:

    (1)java方式
    首先先创建规则并标注属性

    package com.lrq.wechatdemo.rules;
    
    import org.jeasy.rules.annotation.Action;
    import org.jeasy.rules.annotation.Condition;
    import org.jeasy.rules.annotation.Fact;
    import org.jeasy.rules.annotation.Rule;
    import org.jeasy.rules.support.UnitRuleGroup;
    
    /**
     * CreateBy: Liurenquan
     * CreateDate: 2018/12/26
     */
    public class RuleClass {
    
        @Rule(priority = 1) //规则设定优先级
        public static class FizzRule {
            @Condition
            public boolean isFizz(@Fact("number") Integer number) {
                return number % 5 == 0;
            }
    
            @Action
            public void printFizz() {
                System.out.print("fizz\n");
            }
        }
    
        @Rule(priority = 2)
        public static class BuzzRule {
            @Condition
            public boolean isBuzz(@Fact("number") Integer number) {
                return number % 7 == 0;
            }
    
            @Action
            public void printBuzz() {
                System.out.print("buzz\n");
            }
        }
    
        public static class FizzBuzzRule extends UnitRuleGroup {
    
            public FizzBuzzRule(Object... rules) {
                for (Object rule : rules) {
                    addRule(rule);
                }
            }
    
            @Override
            public int getPriority() {
                return 0;
            }
        }
    
        @Rule(priority = 3)
        public static class NonFizzBuzzRule {
    
            @Condition
            public boolean isNotFizzNorBuzz(@Fact("number") Integer number) {
                // can return true, because this is the latest rule to trigger according to
                // assigned priorities
                // and in which case, the number is not fizz nor buzz
                return number % 5 != 0 || number % 7 != 0;
            }
    
            @Action
            public void printInput(@Fact("number") Integer number) {
                System.out.print(number+"\n");
            }
        }
    
    }
    

    然后客户端调用

    package com.lrq.wechatdemo.rules;
    
    import org.jeasy.rules.api.Facts;
    import org.jeasy.rules.api.Rules;
    import org.jeasy.rules.api.RulesEngine;
    import org.jeasy.rules.core.DefaultRulesEngine;
    import org.jeasy.rules.core.RulesEngineParameters;
    
    /**
     * CreateBy: Liurenquan
     * CreateDate: 2018/12/26
     */
    public class RuleJavaClient {
        public static void main(String[] args) {
            // 创建规则引擎
            RulesEngineParameters parameters = new RulesEngineParameters().skipOnFirstAppliedRule(true);
            RulesEngine fizzBuzzEngine = new DefaultRulesEngine(parameters);
    
            // 创建规则集并注册规则
            Rules rules = new Rules();
            rules.register(new RuleClass.FizzRule());
            rules.register(new RuleClass.BuzzRule());
            rules.register(new RuleClass.FizzBuzzRule(new RuleClass.FizzRule(), new RuleClass.BuzzRule()));
            rules.register(new RuleClass.NonFizzBuzzRule());
    
            // 执行规则
            Facts facts = new Facts();
            for (int i = 1; i <= 100; i++) {
                facts.put("number", i);
                fizzBuzzEngine.fire(rules, facts);
                System.out.println();
            }
        }
    
    }
    
    

    (2)yml方式

    resources目录下新建fizzbuzz.yml

    ---
    name: "fizz rule"
    description: "print fizz if the number is multiple of 5"
    priority: 1
    condition: "number % 5 == 0"
    actions:
    - "System.out.println(\"fizz\")"
    
    ---
    name: "buzz rule"
    description: "print buzz if the number is multiple of 7"
    priority: 2
    condition: "number % 7 == 0"
    actions:
    - "System.out.println(\"buzz\")"
    
    ---
    name: "fizzbuzz rule"
    description: "print fizzbuzz if the number is multiple of 5 and 7"
    priority: 0
    condition: "number % 5 == 0 && number % 7 == 0"
    actions:
    - "System.out.println(\"fizzbuzz\")"
    
    ---
    name: "non fizzbuzz rule"
    description: "print the number itself otherwise"
    priority: 3
    condition: "number % 5 != 0 || number % 7 != 0"
    actions:
    - "System.out.println(number)"
    

    客户端调用:

    package com.lrq.wechatdemo.rules;
    
    import org.jeasy.rules.api.Facts;
    import org.jeasy.rules.api.Rules;
    import org.jeasy.rules.api.RulesEngine;
    import org.jeasy.rules.core.DefaultRulesEngine;
    import org.jeasy.rules.core.RulesEngineParameters;
    import org.jeasy.rules.mvel.MVELRuleFactory;
    
    import java.io.FileNotFoundException;
    import java.io.FileReader;
    
    /**
     * CreateBy: Liurenquan
     * CreateDate: 2018/12/26
     */
    public class RuleYmlClient {
    
        public static void main(String[] args) throws FileNotFoundException {
            // create a rules engine
            RulesEngineParameters parameters = new RulesEngineParameters().skipOnFirstAppliedRule(true);
            RulesEngine fizzBuzzEngine = new DefaultRulesEngine(parameters);
    
            // create rules
            Rules rules = MVELRuleFactory.createRulesFrom(new FileReader("fizzbuzz.yml"));
    
            // fire rules
            Facts facts = new Facts();
            for (int i = 1; i <= 100; i++) {
                facts.put("number", i);
                fizzBuzzEngine.fire(rules, facts);
                System.out.println();
            }
        }
    }

    作者:HaleyLiu
    链接:https://www.jianshu.com/p/41ea7a43093c
    来源:简书

    展开全文
  • java重写规则

    千次阅读 2018-08-06 20:02:12
    java的重写规则: 对于异常重写方法不能抛出新的异常或者比被重写方法声明的检查异常更广的检查异常。但是可以抛出更少,更有限或者不抛出异常。重写规则之一:重写方法不能比被重写方法限制有更严格的访问级别。 ...
  • java 规则引擎

    千次阅读 2017-05-29 18:52:25
    最近刚刚接触Java规则引擎,一般的系统而言,业务不是非常复杂,而且变化少,因此很少采用什么规则引擎,最近接触了一个规则引擎的系统,是使用BlazeSoft公司的Blaze来实现的,自己对它正在了解中,把具体的实现...
  • Java文件名规则与 main

    千次阅读 2017-06-29 10:33:04
    1.如果文件中只有一个Java文件名必须与类名一致; 2.一个Java文件中只能有一个public; 3.如果文件中不止一个,文件名必须与public类名一致; 4.如果文件中不止一个,而且没有public,文件名可与...
  • Java集合Streamfilter的使用

    万次阅读 多人点赞 2018-05-11 11:49:42
    之前的Java集合中removeIf的使用一文写了使用removeIf来实现按条件对集合进行过滤。这篇文章使用同样是JDK1.8新加入的Stream中filter方法来实现同样的效果。
  • 2 Java虚拟机加载器结构简述 2.1 JVM三种预定义类型加载器 2.2 加载双亲委派机制介绍和分析 2.3 加载双亲委派示例 3 java程序动态扩展方式 3.1 调用java.lang.Class.forName(…)加载 3.2 用户自定义...
  • 详解 Java 内部

    万次阅读 多人点赞 2018-09-04 00:17:56
    内部Java 里面算是非常常见的一个功能了,在日常开发中我们肯定多多少少都用过,这里总结一下关于 Java 中内部的相关知识点和一些使用内部时需要注意的点。 从种类上说,内部可以分为四类:普通内部...
  • java 命名规则

    千次阅读 2007-01-31 19:14:00
    居然java是一门面向对象的程序设计语言,如其他面向对象的程序设计语言一样,它也有一定的命名规则, 全世界的java程序员都遵守一套为,属性,方法命名的规则,虽然没有硬性规定一定要遵守,不过为了让程序更容易让...
  • 深入理解Java类加载器(一):Java类加载原理解析

    万次阅读 多人点赞 2017-05-15 20:47:44
    每个开发人员对java.lang...本文简述了JVM三种预定义类加载器,即启动类加载器、扩展类加载器和系统类加载器,并介绍和分析它们之间的关系和类加载所采用的双亲委派机制,给出并分析了与Java类加载原理相关的若干问题。
  • java命名规则及规范

    千次阅读 2019-04-23 10:12:09
    java命名规范java项目命名规范前置所有命名规则必须遵循以下规则:包名规范名命名规范(Class)接口命名规范(Interfaces)方法命名规范(Methods)变量命名规范(Variables)实例变量命名规范(Instants ...
  • Java编程规则

    千次阅读 2006-02-25 19:52:00
    Java编程规则 包含了大量有用的建议,帮助大家进行低级程序设计,并提供了代码编写的一般性指导: (1) 类名首字母应该大写。字段、方法以及对象(句柄)的首字母应小写。对于所有标识符,其中包含的所有单词都应紧...
  • Java:类名的命名规则

    万次阅读 多人点赞 2018-08-23 17:07:33
    Java 中定义类名的规则很宽松。名字必须以字母开头,后面可以跟字母和数字的任意组合。 长度基本上没有限制。但是不能使用 Java 保留字(例如,public 或 class)作为类名。 Java 保留字请参看下面的文章。 Java ...
  • 在一个.java文件中可以有多个同级, 其修饰符只可以public/abstract/final/和无修饰符 public修饰的只能有一个,且必须要与文件名相同; 因为jvm虚拟机为了提高查找的速度,使用import语句导入的时候,只会...
  • JAVA之旅(九)——Object,equals,toString,getClass,内部访问规则,静态内部,内部原则,匿名内部 天天被一些琐事骚扰,学习还得继续 一.Object Object是什么呢?我们可以翻阅JAVA API文档看他的...
  • Java中包、、方法、属性、常量的命名规则

    万次阅读 多人点赞 2016-10-08 16:47:31
    1:包(package):用于将完成不同功能的分门别类,放在不同的目录(包)下,包的命名规则:将公司域名反转作为包名。比如www.baidu.com 对于包名:每个字母都需要小写。比如:com.baidu.test;该包下的Test的全名是...
  • java源文件命名规则

    千次阅读 2019-07-01 19:31:59
    在编写Java程序时,源文件名称不能随便取,要遵循以下规则 Java源文件的后缀必须是"*.java",不能是其他文件后缀名. 一般来说Java源文件的名字可以任意取,但是对于一个Java源文件中如果包含了public那么源文件名的...
  • 81.JAVA编程思想——JAVA编程规则

    万次阅读 2016-05-10 22:56:36
    81.JAVA编程思想——JAVA编程规则 (1) 类名首字母应该大写。字段、方法以及对象(句柄)的首字母应小写。对于所有标识符,其中包含的所有单词都应紧靠在一起,而且大写中间单词的首字母。例如: ThisIsAClassName ...
  • Java内部和匿名内部的用法

    万次阅读 多人点赞 2016-07-21 15:46:41
    Java内部和匿名内部的用法 【尊重原创,转载请注明出处】http://blog.csdn.net/guyuealian/article/details/51981163一、内部: (1)内部的同名方法 内部可以调用外部的方法,如果内部有同名方法...
  • Java 源文件的命名规则

    万次阅读 多人点赞 2018-08-22 19:07:35
    Java 程序源文件的命名不是随意的,Java 文件的命名必须满足如下规则。 1、Java 程序源文件的后缀必须是 .java,不能是其他文件后缀名。 2、如果 Java 程序源代码里定义了一个 public ,则该源文件的主文件名...
  • Java类加载机制与Tomcat类加载器架构

    万次阅读 热门讨论 2017-02-26 10:58:11
    Java类加载机制 类加载器 虚拟机设计团队把类加载阶段中的“通过一个类的全限定名来获取描述此类的二进制字节流”这个动作放到Java虚拟机外部去实现,以便让应用程序自己决定如何去获取所需要的类。实现这个动作的...
  • Java中子抛出异常的规则

    千次阅读 2010-07-08 17:49:00
    Java中的异常可以认为是另外一种返回值,所以也跟返回值一样,1、不算在方法签名里,2、子类的方法抛出的异常范围不能超过父类的方法抛出的异常范围,...其他规则参考“异常的限制,异常说明在继承是怎样的?”和“Ja
  • 本文介绍了java的自定义注解及注解编写的规则, 并通过实例来说明下如何使用java的注解. 实例演示了注解在,构造方法,方法和字段的使用. 可以从这里下载到完成的工程代码: ...
  • java类加载过程

    千次阅读 2019-03-10 11:39:38
    JVM将描述数据从.class文件中加载到内存,并对数据进行,解析和初始化,最终形成被JVM直接使用的Java类型。 从被加载到JVM中开始,到卸载为止,整个生命周期包括:加载、验证、准备、解析、初始化、使用和卸载七...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 544,340
精华内容 217,736
关键字:

java类的规则

java 订阅