classloader - Kenyth Zeng on Diigo

08 Dec 09

使用线程上下文类加载器, 可以在执行线程中, 抛弃双亲委派加载链模式, 使用线程上下文里的类加载器加载类.
典型的例子有, 通过线程上下文来加载第三方库jndi实现, 而不依赖于双亲委派.

大部分java app服务器(jboss, tomcat..)也是采用contextClassLoader来处理web服务。
1 more annotations...
- 使用线程上下文加载类, 也要注意, 保证多根需要通信的线程间的类加载器应该是同一个,
  防止因为不同的类加载器, 导致类型转换异常(ClassCastException).

MY(a)ware: Java ClassLoading

jalexoid.blogspot.com/...java-classloading.html - Preview

classloader java php webdev blog

For every request the PHP page is reloaded and until the release of PHP5 there wasn't the concept of Web Application as there is in JEE. The better that could be done was to do little low level unportable tricks like using memory sharing APIs. And even compiled PHP had to be reloaded every time.

InfoQ: JavaRebel: Dynamic Classloading in the JVM

www.infoq.com/...javarebel - Preview

classloader JRebel article

JavaRebel brings Ruby and PHP style dynamic reloading of classes to Java.
This includes adding and removing both methods and fields and the only forbidden changes are to ‘extends’ and ‘implements’ clauses

06 Nov 09

Class Loading in Java: Time to Add Dynamicity? | Javalobby

java.dzone.com/...class-loading-dinamicity - Preview

JRebel hot deploy java discussion .net jvm classloader class article

But not everything can be reloaded by JavaRebel: No reloads with class hierarchy change are possible.
no schema changes are allowed.
8 more annotations...
- Our «irritating little» friend Ruby has this idea of open classes: you may change a class at runtime by adding new methods. This proves that it's possible to do ad-hoc changes.
- Dynamic languages pay a huge performance hit for the ability to update classes dynamically.
- http://classworlds.codehaus.org/
- AFAIK .NET does not reload code, it does full redeploy juts like Java, just application start usually will take less.
- In many cases if you have problems with proxies adding "-Drebel.forbid_bypass=true" will help.
- So if we could only have a jvm-server that could integrate all types of similar jar in the memory.
- They're all compiled with offsets, not labels. When you say "getTitle", the JVM knows the offset within the object structure to the "title" instance variable (if you had, say, 3 instance variables, title being the 3rd slot, all class references (vs, say, char or int),
- Most dynamic languages written on top of the JVM, for example, don't use Java Classes at all for their instances, because they're so rigid.

How JavaRebel Saves Development Time | Javalobby

java.dzone.com/...saving-time-java-development - Preview

JRebel java hot deploy classloader jvm debug dev article how-something-work starred

When debugging through my code in Eclipse, it’s nice to make a change and see that reflected in the running instance straight away with HotSwap.
I’ve often wondered why this is the case with Java when dynamic languages and .NET can handle this quickly.
8 more annotations...
- Finally, OSGi is another approach to take - by splitting your application into smaller modules, it can make the redeployment seem faster.
- With JavaRebel, it’s conceivable that I can start up my debug session and nicely interweave my code changes into the running instance, without anything unexpected happening.
- Why doesn’t this exist already in Java? And how has .NET managed to have this from day one?
- The tricky part in reloading object-oriented code is preserving the object state intact.
- However web development frameworks in .NET are designed around stateless and/or isolated classes so turnaround is usually instantaneous. However I’d assume that writing a complicated business app would run into same problem as Java at some point.
- The need to support class code, structure and layout changes would mean significant compromises in the JVM Just-In-Time compiler. Specifically you’d have to do dependency analysis between classes and make the method lookup and calls more dynamic than they currently are. This would decrease performance, or at least further complicate the design of the JVM. These compromises are already present in dynamic languages VMs, which makes it easy to implement such features there.
- We extend their APIs with an ability to inject and override classes, resources and web resources in the running web applications. We then interpret the rebel.xml file provided by the user to override the deployed classes and resources with the ones found from the project workspace.
- To reload the actual classes we build a kind of our own Just-In-Time compiler, which intercepts loading of every class and rewrites them in a way that makes reloading possible.

JRebel FAQ | ZeroTurnaround.com

www.zeroturnaround.com/faq - Preview

java hot deploy deploy classloader memory leak jvm debug dev FAQ

without having to restart the
container or redeploy the application.
It does not create any new class loaders,
instead, it
extends the existing ones with the ability to manage reloaded classes.
3 more annotations...
- The .class
  file timestamp is then
  monitored for changes in the loaded class and updates are propagated
  through the extended class loader, to your application.
- Importantly, when loading updates to a class, JRebel preserves all
  of
  the existing instances of that class. This allows the application to
  just continue working, but also means that when adding a new instance
  field it will not be initialized in the existing instances, since the
  constructor will not be rerun.
- The Instrumentation API was introduced in Java
  5 and included a limited ability to redefine Java classes on-the-fly.
  Unfortunately it is limited to only changing method bodies (as is
  HotSwap)

JRebel Feature Comparison Matrix | ZeroTurnaround.com

Hot Redeploy JVM HotSwap JRebel

www.zeroturnaround.com/...comparison - Preview

feature comparison hot deploy deploy classloader memory leak starred java jvm debug dev

05 Nov 09

Javassist (Java programming assistant) is a load-time reflective system for Java. It is a class library for editing bytecodes in Java;
it enables Java programs to define a new class at runtime and to modify a class file before the JVM loads it. Unlike other similar systems,
Javassist provides source-level abstraction; programmers can modify a class file without detailed knowledge of the Java bytecode.

www.jboss.org/javassist - Preview

Javassit bytecode aop class opensource classloader

it enables Java programs to define a new class at runtime and to modify a class file before the JVM loads it.
Javassist provides source-level abstraction; programmers can modify a class file without detailed knowledge of the Java bytecode.
2 more annotations...
- Javassist instead can compile a fragment of source text on line (for example, just a single statement).
- Aspect Oriented Programming: Javassist can be a good tool for introducing new methods into a class and for inserting before/after/around advice at the both caller and callee sides.

04 Nov 09

Understanding Network Class Loaders

URLClassLoader

java.sun.com/...classloaders - Preview

network classloader url security article java starred introduction

The mechanism that enabled such dynamic loading is a class loader, which is one of the cornerstones of Java dynamism.
The process of combining the code into an executable native code is called linking - the merging of separately compiled code with shared library code to create an executable application.
6 more annotations...
- Any URL that ends with a '/' is assumed to refer to a directory, otherwise the URL is assumed to refer to a JAR file which will be opened as needed.
- One way to protect against such attacks is by using a security manager, which is not automatically installed when an application is running.
- prompt> java -Djava.security.manager MyLoader2
- The default security manager, however, doesn't allow your application to create its own class loader.
- Such a security policy allows you to state, using grant clauses, what sorts of actions a Java program can and cannot perform.
- A thread's context class loader is, by default, set to the context class loader of the thread's parent.

Serialization - transient / network class loader

i am serializing an object on a local machine.
send it over a socket to remote machine.
remote machine de-serializes.
it needs the classes to de-serialize.
calls back to the local machine.
gets the classes.

forums.sun.com/thread.jspa - Preview

serialization classloader network discussion starred

i am serializing an object on a local machine.

send it over a socket to remote machine.

remote machine de-serializes.

it needs the classes to de-serialize.

calls back to the local machine.

gets the classes.
By the class loader. The class loader doesn't care about 'transient'. The receiver will still need those classes if it uses that field. The class loader can't assume that it won't do that. So it loads the classes of the transient objects. Just like it loads the superclasses, and the classes of all the other fields, member and static.

Copy an Object from one ClassLoader to Another?? - Java answers

bytes.com/...object-one-classloader-another - Preview

java serialization classloader persistence trick

Copy an Object from one ClassLoader to Another
This has the effect of recreating the c2 object in system class

loader.

03 Nov 09

PackageAdmin (OSGi Service Platform Release 4 Version 4.1)

how to eliminate class loader memory leak when uninstalling a bundle: call the refreshPackages method.

www.osgi.org/...PackageAdmin.html - Preview

OSGi api javadoc package classloader memory leak

If no bundles are specified, this method will update or remove any
packages exported by any bundles that were previously updated or
uninstalled since the last call to this method.
One permissible implementation is to stop and restart the Framework.
3 more annotations...
- Add to the
  graph any bundle that is wired to a package that is currently exported by
  a bundle in the graph.
- Each bundle in the graph that is in the ACTIVE state
  will be stopped as described in the Bundle.stop method.
- The effect of this step is that bundles in the graph are no longer
  RESOLVED.

02 Nov 09

ClassLoader说明 - 锈材技术收藏站 - JavaEye技术网站

without code

szqed.javaeye.com/493360 - Preview

classloader java article example starred

大家可以看看sun.misc.Launcher的源码，Bootstrap和Extention就在该文件里。该src可以在sun的网站上下载该压缩包，约60M(jdk-1_5_0-src-scsl.zip)，它不在jdk自带的那个src.zip里。
在一个单虚拟机环境下，标识一个类有两个因素：class的全路径名、该类的ClassLoader。
3 more annotations...
- 代理模型是Java安全模型的保证。譬如，我们自己写一个String.java，并且编译、package到自己的java.lang包下。按照代理模型，当前线程的ClassLoader会将其代理到父ClassLoader，父ClassLoader(最终会是Bootstrap)会找到 rt.jar下的String.class，也就是说我们的String.class不会捣乱。
- 将应用的ClassLoader从默认的Parent-First，改成Parent-Last就可以解决
- 1、应用框架可以自己控制Classes的目录，并且自动部署。
  
  我读过Jive公司的Wildfire(著名的即时通讯服务器)，它自己有一套应用框架，非常灵活，遵循该框架插件规范的的第三方的plug-in放置在指定目录可以自动部署，实现某些扩展功能，如文件传输、语音聊天。

Tacit Records: The Java Class Loader — Developer.com

www.developer.com/...ords-The-Java-Class-Loader.htm - Preview

classloader java article

Since each class loader is itself a class, the question as to which comes first is often asked.
The SecureClassLoader is an extension of ClassLoader and a standard class loader within the JDK runtime library.
5 more annotations...
- java.net.URLClassLoader
- sun.applet.AppletClassLoader
- java.rmi.server.RMIClassLoader
- sun.misc.Launcher$ExtClassLoader
- sun.misc.Launcher$AppClassLoader

Java 编程的动态性，第 1 部分：类和类装入 - K.Y.Z@CSDN - CSDN博客

blog.csdn.net/...35510.aspx - Preview

classloader article tomcat starred

在编写应用程序以使用接口时，可以到运行时才指定其实际实现。这个用于组装应用程序的后联编方法广泛用于 Java 平台，servlet 就是一个常见示例。
每个构造好的类在某种意义上是由装入它的类装入器所“拥有”。类装入器通常保留它们所装入类的映射，从而当再次请求某个类时，能通过名称找到该类。
5 more annotations...
- 这里 Common 类装入器从 Tomcat 安装的某个特定目录的 JAR 文件进行装入，旨在用于在服务器和所有 Web 应用程序之间共享代码。Catalina 装入器用于装入 Tomcat 自己的类，而 Shared 装入器用于装入 Web 应用程序之间共享的类。最后，每个 Web 应用程序有自己的装入器用于其私有类。
- 在 Java 2 平台中将 setContextClassLoader 方法和 getContextClassLoader 方法添加到了 java.lang.Thread 类中。这些方法允许该框架设置类装入器，使得在运行每个应用程序中的代码时可以将类装入器用于该应用程序。
- 类装入器的灵活性甚至允许动态地重新装入已修改的代码

Apache Tomcat 4 - Class Loader HOW-TO

tomcat.apache.org/...class-loader-howto.html - Preview

tomcat doc classloader starred servlet-container servlet 4.1

Apache Tomcat 6.0 - Class Loader HOW-TO

tomcat.apache.org/...class-loader-howto.html - Preview

tomcat i18n doc classloader starred servlet-container servlet 6.0

Some JVMs may
implement this as more than one class loader, or it may not be visible
(as a class loader) at all.
the standard Tomcat 6 startup scripts
($CATALINA_HOME/bin/catalina.sh or
%CATALINA_HOME%\bin\catalina.bat) totally ignore the contents
of the CLASSPATH environment variable itself
6 more annotations...
- All unpacked classes and resources in
  $CATALINA_HOME/lib
- tomcat-i18n-**.jar - Optional JARs containing resource bundles
  for other languages. As default bundles are also included in each
  individual JAR, they can be safely removed if no internationalization
  of messages is needed.
- When a request to load a
  class from the web application's WebappX class loader is processed,
  this class loader will look in the local repositories first,
  instead of delegating before looking.
- All other class loaders in Tomcat 6 follow the usual delegation pattern.
- JDK 1.5 supports a mechanism called the "Endorsed Standards Override
  Mechanism" to allow replacement of APIs created outside of the JCP (i.e.
  DOM and SAX from W3C). It can also be used to update the XML parser
  implementation.
- Tomcat utilizes this mechanism by including the system property setting
  -Djava.endorsed.dirs=$JAVA_ENDORSED_DIRS in the
  command line that starts the container.

21 Apr 09

Is There a Place for OSGi in Enterprise Application Development? (Part 1) | Javalobby

java.dzone.com/...there-place-osgitm-enterprise- - Preview

OSGi article classloader hot deploy SoC

the tough part is not in the introduction of a new release, but rather the removal of an older release, while ensuring continuous operation of the system.
Version management of Java classes or JARs is virtually non-existent.
3 more annotations...
- the effective partitioning of applications into modules is largely unsolved.
- The Spring Dynamic Modules project eliminates the need to write the above boilerplate code for registering services, finding services and tracking services.
- Another twist in the tail is that there could be more than one service that satisfies the dependencies of a bundle. Therefore, cardinality of the dependencies is significant. The manner in which cardinality can be dealt with is beyond the scope of this article.

Thoughts on Software Engineering: Is OSGi going to become the next EJB ?

peterrietzler.blogspot.com/...to-become-next-ejb-bubble.html - Preview

OSGi review blog discussion starred classloader

tracking services and managing all the aspects of what to do when services come and go is nasty
To be honest - I'd never even think about starting an OSGi project without using Spring DM.
12 more annotations...
- OSGi's versioning concept (as a side effect ...) makes a first step of bringing the enforcement of architectural constraints to the developer's daily life by definining export and import packages
- You typically end up in a situation where you constantly tweak your modules build specifications (that creates your manifest) and spread absolutely counter-intuitive dependencies across your whole system.
- you cannot go on without a strong and automated integration testing suite that incorporates OSGi (another thing that Spring DM supports).
- First of all - before considering OSGi I would really check if I have the ultimate requirement to exchange bundles at runtime without shutting down the system
- I do not want my objects to be bound to a runtime environment such as OSGI - therefore I unit-test my classes with the standard Java runtime environment (and hence with the default class loader).
- As most of the frameworks, they only work well if used with POJOs solely. Same goes for OSGi,
- increased overhead of explicitly managing third party library dependencies.
- Any technology which provides productivity barriers will be resisted
- modularity is crucial for these huge software systems. Or for example LinkedIn where over 800 bundles provide the functionality for this very cool website.
- "low-hanging-fruits" of the OSGi mindset:
  
  - Use bundle-scoped micro-services (e.g. by just structuring my software into
  bundles and exporting/importing to/from a service registry)
  - Give developers what makes life easier for them (e.g. classpath scanning,
  automatic startup of bundles if they are on the classpath etc.)
  - BUT: Heavily constrain the developer at build-time (like OSGi does - but
  e.g. through the use of Classycle or similiar tools)
  - BUT: Loosely constrain the developer at runtime (bundles can only get objects
  they are intended to get, e.g. through service lookups)
  - AND: put all these things into relation with existing best practices (e.g.
  Spring DM like IOC, AOP, etc...)
- ClassLoaders mix two responsabilities:
  1) Load the class (and have a chance to instrument it at load-time)
  2) Define the visibility on other classes loaded in the JVM (e.g. via ClassLoader hierarchies.
- Ideally, the concepts of class loading and visibility should be orthogonal. Java should maybe evolve in this direction, by integrating the bundle concept into the JVM for dealing with visibility rules (in a way like .NET assemblies) and let the classloader only deal with class loading.

Unloading classes in java? - Stack Overflow

stackoverflow.com/...unloading-classes-in-java - Preview

classloader GC starred discussion

Is there any way to force the unloading of the class without actually killing the JVM?
The only way that a Class can be unloaded is if the Classloader used is garbage collected. This means, references to every single class and to the classloader itself need to go the way of the dodo.
2 more annotations...
- The OSGi platform strives to do just this, as each bundle has a different classloader and dependencies are resolved by the platform.
- JarClassloader class for every JAR file.
  
  http://java.sun.com/docs/books/tutorial/deployment/jar/jarclassloader.html

Kenyth Zeng's Library tagged classloader → View Popular

重温java之classloader体系结构（含hotswap） - Java - JavaEye论坛