精华内容
下载资源
问答
  • ContextJava出现是如此频繁...先来举几个JAVA中用到Context的例子:(1)JNDI一个javax.naming.InitialContext,它读取JNDI一些配置信息,并内含对象和其在JNDI中注册名称映射信息。请看下面代码Init...

    Context在Java中的出现是如此频繁,但其中文翻译“上下文”又是如此诡异拗口,因此导致很多人不是很了解Context的具体含义是指什么,所以很有必要来深究一下这词的含义。

    先来举几个JAVA中用到Context的例子:

    (1)JNDI的一个类javax.naming.InitialContext,它读取JNDI的一些配置信息,并内含对象和其在JNDI中的注册名称的映射信息。

    请看下面的代码

    InitialContext ic=new InitialContext();

    RMIAdaptor server=(RMIAdaptor)ic.lookup("jmx/invoker/RMIAdaptor");

    这是一段JBoss中获取MBean的远程调用类的代码。

    在这里面通过InitialContext中JNDI注册的名称“jmx/invoker/RMIAdaptor”来获得RMIAdaptor对象。

    这和JAVA集合中的MAP有点象,有一个String的key,key对映着它的对象。

    (2)再来看看下面Spring中最常见的几句代码。

    ApplicationContext是内含configuration.xml配置文件的信息,使得可以通过getBean用名称得到相应的注册对象。

    ApplicationContext ctx= newFileSystemXmlApplicationContext("configuration.xml");

    Object obj= ctx.getBean("Object_Name");

    从上面的代码,我很能体会到Context所代表的意义:公用信息、环境、容器....。

    所以我觉得Context翻译成上下文并不直观,按照语言使用的环境,翻译成“环境”、“容器”可能更好。把Context翻译成“上下文”只是不直观罢了,不过也没大错。

    我们来看看中文的“上下文”是什么意思。我们常说听话传话不能“断章取义”,而要联系它的“上下文”来看。比如,小丽对王老五说“我爱你”,光看这句还以为在说情话呢。但一看上下文--“虽然我爱你,但你太穷了,我们还是分手吧”,味道就完全变了。从这里来看“上下文”也有“环境”的意思,就是语言的环境。

    PS:

    上下文其实是一个抽象的概念。我们常见的上下文有Servlet中的pageContext,访问JNDI时候用的Context。写过这些代码的人可能比较容易理解,其实他们真正的作用就是承上启下。比如说pageContext他的上层是WEB容器,下层是你写的那个Servlet类,pageContext作为中间的通道让Servlet 和Web容器进行交互。再比如访问JNDI的Context,他的上层是JNDI服务器(可能是远程的),下层是你的应用程序,他的作用也是建立一个通道让你能访问JNDI服务器,同时也让JNDI服务器接受你的请求,同样起到交互作用。

    展开全文
  • 疑惑以前在看源码的时候,总是会遇到框架里的代码使用Thread.currentThread.getContextClassLoader()获取当前线程的Context类加载器,通过这个Context类加载器去加载类。我们平时在程序中写代码的时候,遇到要动态...

    疑惑

    以前在看源码的时候,总是会遇到框架里的代码使用Thread.currentThread.getContextClassLoader()获取当前线程的Context类加载器,通过这个Context类加载器去加载类。

    我们平时在程序中写代码的时候,遇到要动态加载类的时候,一般使用Class.forName()的方式加载我们需要的类。比如最常见的,当我们进行JDBC编程的时候,我们通过Class.forName()去加载JDBC的驱动。

    try{return Class.forName("oracle.jdbc.driver.OracleDriver");

    }catch(ClassNotFoundException e) {//skip

    }

    那么为什么当我们使用Class.forName()的方式去加载类的时候,如果类找不到,我们还要尝试用Thread.currentThread.getContextLoader()获取的类加载器去加载类呢?比如我们可能会碰到下面这种代码:

    try{returnClass.forName(className);

    }catch(ClassNotFoundException e) {//skip

    }

    ClassLoader ctxClassLoader=Thread.currentThread().getContextClassLoader();if (ctxClassLoader != null) {try{

    clazz=ctxClassLoader.loadClass(className);

    }catch(ClassNotFoundException e) {//skip

    }

    }

    这里加粗的部分,就是使用了Thread.currentThread.getContextLoader()获取的加载器去加载类。显然,Class.forName()加载类的时候使用的类加载器可能和Thread.currentThread.getContextLoader()获取的类加载器是不同的。那么为什么会出现不同呢?

    JAVA的类加载器

    要理解为什么会用到Thread.currentThread.getContextLoader()获取的这个类加载器之前,我们先来了解下JVM里使用的类加载器(ClassLoader)。

    JVM默认有三种类加载器:

    Bootstrap Class Loader

    Extension Class Loader

    System Class Loader

    Bootstrap Class Loader

    Bootstrap Class Loader类加载器是JDK自带的一款类加载器,用于加载JDK内部的类。Bootstrap类加载器用于加载JDK中$JAVA_HOME/jre/lib下面的那些类,比如rt.jar包里面的类。Bootstrap类加载器是JVM的一部分,一般采用native代码编写。

    Extension Class Loader

    Extension Class Loader类加载器主要用于加载JDK扩展包里的类。一般$JAVA_HOME/lib/ext下面的包都是通过这个类加载器加载的,这个包下面的类基本上是以javax开头的。

    System Class Loader

    System Class Loader类加载器也叫应用程序类加载器(AppClassLoader)。顾名思义,这个类加载器就是用来加载开发人员自己平时写的应用代码的类的。System类加载器是用于加载存放在classpath路径下的那些应用程序级别的类的。

    下面的代码列举出了这三个类加载器:

    public classMainClass {public static voidmain(String[] args) {

    System.out.println(Integer.class.getClassLoader());

    System.out.println(Logging.class.getClassLoader());

    System.out.println(MainClass.class.getClassLoader());

    }

    }

    其中获取Bootstrap类加载器永远返回null值

    null # Bootstrap类加载器

    sun.misc.Launcher$ExtClassLoader@5e2de80c # Extension类加载器

    sun.misc.Launcher$AppClassLoader@18b4aac2 # System类加载器

    双亲委派模型

    上面介绍的三种类加载器,并不是孤立的,他们之间有一个层次关系:

    2d6c8e58383bf6ade4675d85bc6ee0bc.png

    三个类加载器之间通过这个层次关系协同工作,一起负责类的加载工作。上面的这种层次模型称为类加载器的“双亲委派”模型。双亲委派模型要求,除了最顶层的Bootstrap类加载器之外,所有的类加载器都必须有一个parent加载器。当类加载器加载类的时候,首先检查缓存中是否有已经被加载的类。如果没有,则优先委托它的父加载器去加载这个类,父加载器执行和前面子加载器一样的工作,直到请求达到顶层的Bootstrap类加载器。如果父加载器不能加载需要的类,那么这个时候才会让子加载器自己去尝试加载这个类。工作原理类似于下面这种方式:

    0ff977475879b0909035f073e630bbc0.png

    我们可以通过JDK里ClassLoader里面的代码一窥双亲委派机制的实现方式,代码实现在ClassLoader.loadClass()里面

    rotected Class> loadClass(String name, booleanresolve)throwsClassNotFoundExceptionsynchronized(getClassLoadingLock(name)) {//First, check if the class has already been loaded

    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//to find the class.

    long t1 =System.nanoTime();

    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);

    }returnc;

    }

    采用双亲委派的方式组织类加载器,一个好处是为了安全。如果我们自己定义了一个String类,希望将这个String类替换掉默认Java中的java.lang.String的实现。

    我们将自己实现的String类的class文件放到classpath路径下,当我们使用类加载器去加载我们实现的String类的时候,首先,类加载器会将请求委托给父加载器,通过层层委派,最终由Bootstrap类加载器加载rt.jar包里的String类型,然后一路返回给我们。在这个过程中,我们的类加载器忽略掉了我们放在classpath中自定义的String类。

    如果没有采用双亲委派机制,那么System类加载器可以在classpath路径中找到String的class文件并加载到程序中,导致JDK中的String实现被覆盖。所以类加载器的这种工作方式,在一定程度上保证了Java程序可以安全稳定的运行。

    线程上下文类加载器

    上面讲了那么多类加载器相关的内容,可还是没有讲到今天的主题,线程上下文类加载器。

    到这里,我们已经知道Java提供了三种类加载器,并且按照严格的双亲委派机制协同工作。表面上,似乎很完美,但正是这种严格的双亲委派机制导致在加载类的时候,存在一些局限性。

    当我们更加基础的框架需要用到应用层面的类的时候,只有当这个类是在我们当前框架使用的类加载器可以加载的情况下我们才能用到这些类。换句话说,我们不能使用当前类加载器的子加载器加载的类。这个限制就是双亲委派机制导致的,因为类加载请求的委派是单向的。

    虽然这种情况不多,但是还是会有这种需求。比较典型的,JNDI服务。JNDI提供了查询资源的接口,但是具体实现由不同的厂商实现。这个时候,JNDI的代码是由JVM的Bootstrap类加载器加载,但是具体的实现是用户提供的JDK之外的代码,所以只能由System类加载器或者其他用户自定义的类加载器去加载,在双亲委派的机制下,JNDI获取不到JNDI的SPI的实现。

    为了解决这个问题,引入了线程上下文类加载器。通过java.lang.Thread类的setContextClassLoader()设置当前线程的上下文类加载器(如果没有设置,默认会从父线程中继承,如果程序没有设置过,则默认是System类加载器)。有了线程上下文类加载器,应用程序就可以通过java.lang.Thread.setContextClassLoader()将应用程序使用的类加载器传递给使用更顶层类加载器的代码。比如上面的JNDI服务,就可以利用这种方式获取到可以加载SPI实现的类加载器,获取需要的SPI实现类。

    72162e01256fcca2febdae7a90fedef4.png

    可以看到,引入线程类加载器实际是对双亲委派机制的破坏,但是却提供了类加载的灵活性。

    解惑

    回到开头,框架的代码为了加载框架之外用户实现的类,由于这些类可能没法通过框架使用的类加载器进行加载,为了绕过类加载器的双亲委派模型,采用Thread.getContextClassLoader()的方式去加载这些类。

    展开全文
  • java Context类

    2020-10-25 15:38:32
    至于context怎么来,还需要继续溯源 public interface MapContext<KEYIN,VALUEIN,KEYOUT,VALUEOUT> extends TaskInputOutputContext<KEYIN,VALUEIN,KEYOUT,VALUEOUT> { /** * Get the input split...

    首先,Context是一个内部类,从哪看出来的呢?如下

    public class Mapper<KEYIN, VALUEIN, KEYOUT, VALUEOUT> {
    
      /**
       * The <code>Context</code> passed on to the {@link Mapper} implementations.
       */
      public abstract class Context
        implements MapContext<KEYIN,VALUEIN,KEYOUT,VALUEOUT> {
      }
      }
    
    

    内部类有啥好处呢?也就是Mapper类的参数那么Context可以很方便的访问到.
    在这里插入图片描述
    Context类实现了MapContext接口.
    看一下.有一个获取分片的方法.至于context怎么来的,还需要继续溯源

    public interface MapContext<KEYIN,VALUEIN,KEYOUT,VALUEOUT> 
      extends TaskInputOutputContext<KEYIN,VALUEIN,KEYOUT,VALUEOUT> {
    
      /**
       * Get the input split for this map.
       */
      public InputSplit getInputSplit();
      
    }
    

    获取是否有下一个键值对,以及当前键值对.还有写入方法在这里定义了,就是把k2,v2写出去.写到哪里呢?

    public interface TaskInputOutputContext<KEYIN,VALUEIN,KEYOUT,VALUEOUT> 
           extends TaskAttemptContext {
    
      /**
       * Advance to the next key, value pair, returning null if at end.
       * @return the key object that was read into, or null if no more
       */
      public boolean nextKeyValue() throws IOException, InterruptedException;
     
      /**
       * Get the current key.
       * @return the current key object or null if there isn't one
       * @throws IOException
       * @throws InterruptedException
       */
      public KEYIN getCurrentKey() throws IOException, InterruptedException;
    
      /**
       * Get the current value.
       * @return the value object that was read into
       * @throws IOException
       * @throws InterruptedException
       */
      public VALUEIN getCurrentValue() throws IOException, InterruptedException;
    
      /**
       * Generate an output key/value pair.
       */
      public void write(KEYOUT key, VALUEOUT value) 
          throws IOException, InterruptedException;
    
      /**
       * Get the {@link OutputCommitter} for the task-attempt.
       * @return the <code>OutputCommitter</code> for the task-attempt
       */
      public OutputCommitter getOutputCommitter();
    }
    

    继续溯源.TaskInputOutputContext又继承了TaskAttemptContext接口,这个接口中包含一些job信息.

    public interface TaskAttemptContext extends JobContext, Progressable {
    
      /**
       * Get the unique name for this task attempt.
       */
      public TaskAttemptID getTaskAttemptID();
    
      /**
       * Set the current status of the task to the given string.
       */
      public void setStatus(String msg);
    
      /**
       * Get the last set status message.
       * @return the current status message
       */
      public String getStatus();
      
      /**
       * The current progress of the task attempt.
       * @return a number between 0.0 and 1.0 (inclusive) indicating the attempt's
       * progress.
       */
      public abstract float getProgress();
    
      /**
       * Get the {@link Counter} for the given <code>counterName</code>.
       * @param counterName counter name
       * @return the <code>Counter</code> for the given <code>counterName</code>
       */
      public Counter getCounter(Enum<?> counterName);
    
      /**
       * Get the {@link Counter} for the given <code>groupName</code> and 
       * <code>counterName</code>.
       * @param counterName counter name
       * @return the <code>Counter</code> for the given <code>groupName</code> and 
       *         <code>counterName</code>
       */
      public Counter getCounter(String groupName, String counterName);
    
    }
    

    继续溯源

    public interface JobContext extends MRJobConfig {
      /**
       * Return the configuration for the job.
       * @return the shared configuration object
       */
      public Configuration getConfiguration();
    
      /**
       * Get credentials for the job.
       * @return credentials for the job
       */
      public Credentials getCredentials();
    
      /**
       * Get the unique ID for the job.
       * @return the object with the job id
       */
      public JobID getJobID();
      
      /**
       * Get configured the number of reduce tasks for this job. Defaults to 
       * <code>1</code>.
       * @return the number of reduce tasks for this job.
       */
      public int getNumReduceTasks();
      
      /**
       * Get the current working directory for the default file system.
       * 
       * @return the directory name.
       */
      public Path getWorkingDirectory() throws IOException;
    
      /**
       * Get the key class for the job output data.
       * @return the key class for the job output data.
       */
      public Class<?> getOutputKeyClass();
      
      /**
       * Get the value class for job outputs.
       * @return the value class for job outputs.
       */
      public Class<?> getOutputValueClass();
    
      /**
       * Get the key class for the map output data. If it is not set, use the
       * (final) output key class. This allows the map output key class to be
       * different than the final output key class.
       * @return the map output key class.
       */
      public Class<?> getMapOutputKeyClass();
    
      /**
       * Get the value class for the map output data. If it is not set, use the
       * (final) output value class This allows the map output value class to be
       * different than the final output value class.
       *  
       * @return the map output value class.
       */
      public Class<?> getMapOutputValueClass();
    
      /**
       * Get the user-specified job name. This is only used to identify the 
       * job to the user.
       * 
       * @return the job's name, defaulting to "".
       */
      public String getJobName();
    
      /**
       * Get the {@link InputFormat} class for the job.
       * 
       * @return the {@link InputFormat} class for the job.
       */
      public Class<? extends InputFormat<?,?>> getInputFormatClass() 
         throws ClassNotFoundException;
    
      /**
       * Get the {@link Mapper} class for the job.
       * 
       * @return the {@link Mapper} class for the job.
       */
      public Class<? extends Mapper<?,?,?,?>> getMapperClass() 
         throws ClassNotFoundException;
    
      /**
       * Get the combiner class for the job.
       * 
       * @return the combiner class for the job.
       */
      public Class<? extends Reducer<?,?,?,?>> getCombinerClass() 
         throws ClassNotFoundException;
    
      /**
       * Get the {@link Reducer} class for the job.
       * 
       * @return the {@link Reducer} class for the job.
       */
      public Class<? extends Reducer<?,?,?,?>> getReducerClass() 
         throws ClassNotFoundException;
    
      /**
       * Get the {@link OutputFormat} class for the job.
       * 
       * @return the {@link OutputFormat} class for the job.
       */
      public Class<? extends OutputFormat<?,?>> getOutputFormatClass() 
         throws ClassNotFoundException;
    
      /**
       * Get the {@link Partitioner} class for the job.
       * 
       * @return the {@link Partitioner} class for the job.
       */
      public Class<? extends Partitioner<?,?>> getPartitionerClass() 
         throws ClassNotFoundException;
    
      /**
       * Get the {@link RawComparator} comparator used to compare keys.
       * 
       * @return the {@link RawComparator} comparator used to compare keys.
       */
      public RawComparator<?> getSortComparator();
    
      /**
       * Get the pathname of the job's jar.
       * @return the pathname
       */
      public String getJar();
    
      /**
       * Get the user defined {@link RawComparator} comparator for
       * grouping keys of inputs to the combiner.
       *
       * @return comparator set by the user for grouping values.
       * @see Job#setCombinerKeyGroupingComparatorClass(Class)
       */
      public RawComparator<?> getCombinerKeyGroupingComparator();
    
        /**
         * Get the user defined {@link RawComparator} comparator for
         * grouping keys of inputs to the reduce.
         *
         * @return comparator set by the user for grouping values.
         * @see Job#setGroupingComparatorClass(Class)
         * @see #getCombinerKeyGroupingComparator()
         */
      public RawComparator<?> getGroupingComparator();
      
      /**
       * Get whether job-setup and job-cleanup is needed for the job 
       * 
       * @return boolean 
       */
      public boolean getJobSetupCleanupNeeded();
      
      /**
       * Get whether task-cleanup is needed for the job 
       * 
       * @return boolean 
       */
      public boolean getTaskCleanupNeeded();
    
      /**
       * Get whether the task profiling is enabled.
       * @return true if some tasks will be profiled
       */
      public boolean getProfileEnabled();
    
      /**
       * Get the profiler configuration arguments.
       *
       * The default value for this property is
       * "-agentlib:hprof=cpu=samples,heap=sites,force=n,thread=y,verbose=n,file=%s"
       * 
       * @return the parameters to pass to the task child to configure profiling
       */
      public String getProfileParams();
    
      /**
       * Get the range of maps or reduces to profile.
       * @param isMap is the task a map?
       * @return the task ranges
       */
      public IntegerRanges getProfileTaskRange(boolean isMap);
    
      /**
       * Get the reported username for this job.
       * 
       * @return the username
       */
      public String getUser();
      
      /**
       * Originally intended to check if symlinks should be used, but currently
       * symlinks cannot be disabled.
       * @return true
       */
      @Deprecated
      public boolean getSymlink();
      
      /**
       * Get the archive entries in classpath as an array of Path
       */
      public Path[] getArchiveClassPaths();
    
      /**
       * Get cache archives set in the Configuration
       * @return A URI array of the caches set in the Configuration
       * @throws IOException
       */
      public URI[] getCacheArchives() throws IOException;
    
      /**
       * Get cache files set in the Configuration
       * @return A URI array of the files set in the Configuration
       * @throws IOException
       */
    
      public URI[] getCacheFiles() throws IOException;
    
      /**
       * Return the path array of the localized caches
       * @return A path array of localized caches
       * @throws IOException
       * @deprecated the array returned only includes the items the were 
       * downloaded. There is no way to map this to what is returned by
       * {@link #getCacheArchives()}.
       */
      @Deprecated
      public Path[] getLocalCacheArchives() throws IOException;
    
      /**
       * Return the path array of the localized files
       * @return A path array of localized files
       * @throws IOException
       * @deprecated the array returned only includes the items the were 
       * downloaded. There is no way to map this to what is returned by
       * {@link #getCacheFiles()}.
       */
      @Deprecated
      public Path[] getLocalCacheFiles() throws IOException;
    
      /**
       * Get the file entries in classpath as an array of Path
       */
      public Path[] getFileClassPaths();
      
      /**
       * Get the timestamps of the archives.  Used by internal
       * DistributedCache and MapReduce code.
       * @return a string array of timestamps 
       */
      public String[] getArchiveTimestamps();
    
      /**
       * Get the timestamps of the files.  Used by internal
       * DistributedCache and MapReduce code.
       * @return a string array of timestamps 
       */
      public String[] getFileTimestamps();
    
      /** 
       * Get the configured number of maximum attempts that will be made to run a
       * map task, as specified by the <code>mapred.map.max.attempts</code>
       * property. If this property is not already set, the default is 4 attempts.
       *  
       * @return the max number of attempts per map task.
       */
      public int getMaxMapAttempts();
    
      /** 
       * Get the configured number of maximum attempts  that will be made to run a
       * reduce task, as specified by the <code>mapred.reduce.max.attempts</code>
       * property. If this property is not already set, the default is 4 attempts.
       * 
       * @return the max number of attempts per reduce task.
       */
      public int getMaxReduceAttempts();
    
    }
    

    总结一下,就是

    • context是一个Mapper的内部类
    • context可以获取一些Job相关的信息.
    展开全文
  • 创建一个让其实现org.springframework.context.ApplicationContextAware接口来让Spring在启动时候为我们注入ApplicationContext对象.示例代码:import org.springframework.beans.BeansException;import org....

    实现

    1.创建一个类让其实现org.springframework.context.ApplicationContextAware接口来让Spring在启动的时候为我们注入ApplicationContext对象.

    示例代码:

    import org.springframework.beans.BeansException;

    import org.springframework.context.ApplicationContext;

    import org.springframework.context.ApplicationContextAware;

    public class MyApplicationContextUtil implements ApplicationContextAware {

    private static ApplicationContext context;

    //声明一个静态变量保存

    public void setApplicationContext(ApplicationContext contex) throws BeansException {

    this.context=contex;

    }

    public static ApplicationContext getContext(){

    return context;

    }

    public final static Object getBean(String beanName){

    return context.getBean(beanName);

    }

    public final static Object getBean(String beanName, Class> requiredType) {

    return context.getBean(beanName, requiredType);

    }

    }

    2.在applicationContext.xml文件中配置此bean,以便让Spring启动时自动为我们注入ApplicationContext对象.

    例:

    3.有了这个ApplicationContext之后我们就可以调用其getBean("beanName")方法来得到由Spring 管理所有对象.

    原理

    Spring中提供一些Aware相关的接口,BeanFactoryAware、 ApplicationContextAware、ResourceLoaderAware、ServletContextAware等等,其中最常用到的是ApplicationContextAware。实现ApplicationContextAware的Bean,在Bean被初始后,将会被注入ApplicationContext的实例。ApplicationContextAware提供了publishEvent()方法,实现Observer(观察者)设计模式的事件传播机,提供了针对Bean的事件传播功能。通过Application.publishEvent方法,我们可以将事件通知系统内所有的ApplicationListener。

    Spring事件处理一般过程:

    ◆定义Event类,继承org.springframework.context.ApplicationEvent。

    ◆编写发布事件类Publisher,实现org.springframework.context.ApplicationContextAware接口。

    ◆覆盖方法setApplicationContext(ApplicationContext applicationContext)和发布方法publish(Object obj)。

    ◆定义时间监听类EventListener,实现ApplicationListener接口,实现方法onApplicationEvent(ApplicationEvent event)。

    MessageEventJava代码

    import org.springframework.context.ApplicationEvent;

    /**

    * 定义事件信息

    * @author new

    *

    */

    public class MessageEvent extends ApplicationEvent {

    private String message;

    public void setMessage(String message){

    this.message = message;

    }

    public String getMessage(){

    return message;

    }

    public MessageEvent(Object source, String message) {

    super(source);

    this.message = message;

    // TODO Auto-generated constructor stub

    }

    private static final long serialVersionUID = 1L;

    }

    PublisherJava代码

    import org.springframework.beans.BeansException;

    import org.springframework.context.ApplicationContext;

    import org.springframework.context.ApplicationContextAware;

    import org.springframework.context.support.FileSystemXmlApplicationContext;

    public class Publisher implements ApplicationContextAware {

    private ApplicationContext context;

    @Override

    public void setApplicationContext(ApplicationContext arg0)

    throws BeansException {

    // TODO Auto-generated method stub

    this.context = arg0;

    }

    public void publish(String message){

    context.publishEvent(new MessageEvent(this,message));

    }

    public static void main(String[] args) {

    ApplicationContext ctx = new FileSystemXmlApplicationContext("src/applicationContext.xml");

    Publisher pub = (Publisher) ctx.getBean("publisher");

    pub.publish("Hello World!");

    pub.publish("The quick brown fox jumped over the lazy dog");

    }

    }

    MessageEventListenerJava代码

    import org.springframework.context.ApplicationEvent;

    import org.springframework.context.ApplicationListener;

    public class MessageEventListener implements ApplicationListener {

    @Override

    public void onApplicationEvent(ApplicationEvent event) {

    // TODO Auto-generated method stub

    if(event instanceof MessageEvent){

    MessageEvent msEvent = (MessageEvent)event;

    System.out.println("Received: " + msEvent.getMessage());

    }

    }

    }

    在运行期,ApplicationContext会自动在当前的所有Bean中寻找ApplicationListener接口的实现,并将其作为事件接收对象。当Application.publishEvent方法调用时,所有的ApplicationListener接口实现都会被激发,每个ApplicationListener可根据事件的类型判断是否是自己需要处理的事件,如上面的ActionListener只处理ActionEvent事件。

    展开全文
  • 起因是我想要获取一个相对路径,需要用到servletContextgetRealPath()方法,于是上网搜索...后来发现这种方法只有在从浏览器打开时候才能获取到ServletContext,否则在普通的java类中会报空指针错误(找不到Servl...
  • 起因是我想要获取一个相对路径,需要用到servletContextgetRealPath()方法,于是上网搜索,找到两种方法来获取ServletContext.方法1:第一种方法是这样:ServletActionContext.getServletContext();或者...
  • java上下文Context类

    2014-05-05 19:48:00
    ContextJava出现是如此频繁,但其中文翻译“上下文”又是如此诡异拗口,因此导致很多人不是很了解Context的具体含义是指什么,所以很有必要来深究一下这词含义。 先来举几个JAVA中用到Context的...
  • 以下代码示例是从...我完整问题是......Wikimain方法://StrategyExample test applicationclass StrategyExample {public static void main(String[] args) {Context context;// Three contexts following ...
  • 2) Context:是一个访问application环境全局信息接口,通过它可以访问application资源和相关的类,其主要功能如下:启动Activity启动和停止Service发送广播消息(Intent)注册广播消息(Intent)接收者可以访问APK中...
  • 1. 什么是SSLSocketJDK文档指出,SSLSocket扩展Socket并提供使用SSL或TLS协议安全套接字。这种套接字是正常流套接字,但是它们在基础网络...2. SSLSocket和相关SSLSocket来自jsse(JavaSecure Socket Extensi...
  • java SSLContext

    千次阅读 2017-05-01 21:26:41
    java SSLContext ...1 什么是SSLSocket2 SSLSocket和相关3 SSLContext的使用4 SSLSocket和SSLServerSocket使用 41 SSLServerSocket42 SSLSocket 1. 什么是SSLSocket JDK文档指出,SSLSocket扩展Soc
  • import io.netty.handler.ssl... //导入方法依赖package包/public boolean tryConnect(boolean ssl, SimpleChannelInboundHandler default_handler, Auth auth, Runnable cancelTask){try{eventLoopGroup = Netw...
  • @Context注入可用于,但不能使其与对象一起使用.ContainerRequestFilter中httpServletRequest产生空指针.Dropwizard版本:-1.1.0ContainerRequestFilterpublic class ApplicationIPAuthFilter implements ...
  • import io.netty.handler.ssl... //导入方法依赖package包/public void start() throws CertificateException, SSLException, InterruptedException {// Configure SSL.final SslContext sslCtx;if (ssl) {SelfS...
  • 普通Java类获取context

    千次阅读 2018-11-15 10:43:54
    都知道最简单获得SharedPreferences方法是context.getSharedPreferences,但是我存储数据环节放在了自定义Interceptor(okhttp3)interceptor方法里面,这个是无法从Activity/Fragment里获取context的,...
  • 一些class,本身没有context成员用以保存调用者的context或application,也不像Fragment那样可以直接getActivity(),在不改动调用者调用参数(向这个需要使用context的class传递context)的前提下,能不能做到获取...
  • ContextJava出现是如此频繁....我行说说我看法吧先来举几个JAVA中用到Context的例子(1)JNDI一个javax.naming.InitialContext,它读取JNDI一些配置信息,并内含对象和其在JNDI中注册名称...
  • ContextJava出现是如此频繁...先来举几个JAVA中用到Context的例子(1)JNDI一个javax.naming.InitialContext,它读取JNDI一些配置信息,并内含对象和其在JNDI中注册名称映射信息。请看下面代码Initi...
  • //导入方法依赖package包//*** 业务线程池* 用以单独处理业务handler,避免造成IO线程阻塞* TODO 是否需要使用业务线程池,线程池数量该怎么确定* private static final EventExecutorGroup EVENT_EXECUTOR...
  • 使用Spring-Context的注解实现依赖注入...我们将Cinema.java的头部标注为@Component说明该交由Spring托管。而Cinema.java中的属性MoviceService标注为@Autowired,则Spring在初始化Cinema时会从Application Con...
  • [Java教程]spring context:component0 2014-07-01 00:00:33在注意:如果配置了那么标签就可以不用再1.2.在说明这两个子标签前,先说一下有一个use-default-filters属性,改属性默认为true,这就意味着会扫描指定包下...
  • WEB项目初始化过程:在启动Web项目时,容器(比如Tomcat)会读web.xml配置文件中两个节点和。...容器创建中的类实例,即创建监听(备注:listener定义的类可以是自定义的类但必须需要继承ServletContext...
  • 我有一个简单按钮,当按钮被点击时,我希望另一个被安装并调用所有方法。按钮:public class ButtonActivity extends Activity {Button myButton;TextView myLabel;@Overridepublic void onCreate(Bundle ...
  • 今天在看一个小项目时候,第一次见到InitialContex这个,感觉好神奇,他一个方法loookup()似乎好牛逼,于是网上查了查,原来是与JNDI有关一个,由javax提供,详细使用我也不是很明白,没有使用过,简单...
  • 很多时候需要从spring中取出相应对象,很多时候又需要将对象注入到spring context中。小卒碰到了这样问题。在构件中有DAO. 其他构件需要复用这个DAO,但是连接配置各不相同,并且也有开发测试环境,milestone环境...
  • java的context上下文

    千次阅读 2018-09-06 09:43:28
    ContextJava出现是如此...先来举几个JAVA中用到Context的例子(1)JNDI一个javax.naming.InitialContext,它读取JNDI一些配置信息,并内含对象和其在JNDI中注册名称映射信息。请看下面代码 Ini...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 4,778
精华内容 1,911
关键字:

java的context类

java 订阅