10:11 2006-8-25

 

10:11 2006-8-25

类装载器是通过类名加上.class然后到硬盘去寻找相应的class文件，然后加载到内存中，生成Class物件，这是一般的类装载方法。

还可以动态创建类的字节码，然后放到内存中由JVM去调用。字节码也是被装载到HashTable里面，防止重复加载

 

在源文件出现的字符串会被编译为UTF-8码

 

AOP:面向方面的编程。不是面向对象可以解决的，是面向系统的。

如：

func1              func2            fun3

{                  {                {

-----------------------------------------------

          进行统一的系统的安全检查

-----------------------------------------------

 ...               ...              ...

-----------------------------------------------

            截断，自己动作

-----------------------------------------------

 ...              ...               ... 

}                  }                }

 

 

取得类的Class物件

类.class属性

类物件.getClass();

Class.forName("类名");

 

类装载器：继承java.lang.ClassLoader抽象类

装载类的时候调用 Class<?> ClassLoader.loadClass(String name)函数

装载器可以有多个。

装载方式：

1.装载器也是Java类，也要被装载。JVM内迁入BootStrp的类装载器。他不是Java类，由特定于OS的本地代码用C写的。

rt.jar是JVM的核心包，该包不依赖于Classpath的指定。由Class.getClassLoader可以取得装载器类，如是由bootStrap装载时返回null,因为

它不是java类。rt.jar中有两个java类的装载器 .ExtClassLoader他找到<java_Home>/jre/lib/ext目录下去装载。

AppClassLoader是用来装载ClassPath下的类文件的。当使用Java命令去执行一个类时。ExtClassLoader是ApClassLoader的父类。

ExtClassLoader没有父类(BootStrap)

 

 

所有类装载器时，有父子关系的树形结构进行组织。类装载器是委托模式，一直沿着继承向上调用。可以避免二次加载。当两个类加载器继承

于同一个父类时，不会从附加载同一个父类，内存中只会有一份父类

 

3.若使用Class.forName()是可以指定ClassLoader，

 

 

一个装载器只能创建某个类的一份字节码数据。    

 

例如类A是由一个ALoader装载的，类B是由BLoader装载的，BLoader是ALoader的子级，当A要调用B类时，由于无法调用子级的装载器，只能向父级调用，所以会发现找不到B类的问题

 

编写了Hannon的Dos下的简易图版本

Buildfile: build.xml

run:

 

 

面向接口编程，不要具体到类,如：Encode( InputStream in , OutputStream out );

InputStream ::read()的函数传回int防止了文件的解释不完全，但是为什么不 使用short呢？使用short可以节省空间，也可以达到如上效果

 

 

 

 

写类的装载器

：继承ClassLoader抽象

 

必定要实现

protected Class<?> findClass(String name)throws ClassNotFoundException

public Class<?> loadClass() throws ClassNotFoundException    //内部调用findClass,

loadClass会先判断是否装载过，然后再通过父类去载，若载不了就呼叫自己类的findClass函数。若改写了loadClass则不会按照委托机制不会通过父类

 

注意：

（已会）覆盖父类时要如何抛出异常

 

今晚写了网路经由类装载器

服务器:
ServerClassGiver.java文件：
import java.io.*;
import java.awt.event.*;
import javax.swing.*;
import java.awt.*;
import java.net.*;
import javax.swing.filechooser.FileFilter;

class ClassFilter extends FileFilter
{
 public boolean accept( File pathName)
 {
  return pathName.getPath().endsWith(".class");
 } 
 public String getDescription()
 {
  return "java's Class file *.class";
 }
}

public class ServerClassGiver extends JFrame implements ActionListener
{
 private ServerSocket sock;
 private JTextField  PathText = new JTextField("Please Input the class file");
 private JButton BrowseBtn  = new JButton("Browse");
 private JButton AcceptBtn = new JButton("Accept");
 
 private File fileToSend = null;
 
 
 public ServerClassGiver( int port ) throws Exception
 {
  sock = new ServerSocket( port );  
  setDefaultCloseOperation( EXIT_ON_CLOSE );
  setBounds( 0,0,200,300 );
   
  AcceptBtn.setEnabled(false);
  PathText.setEditable(false);
  
  BrowseBtn.addActionListener(this);
  AcceptBtn.addActionListener(this);
    
  this.setLayout( new FlowLayout() );
  this.getContentPane().add( PathText );
  this.getContentPane().add( BrowseBtn );
  this.getContentPane().add( AcceptBtn );

  setVisible(true);  
 }
 

  
 public void actionPerformed( ActionEvent e )
 {
  if( e.getActionCommand().equals("Browse"))
  {
   JFileChooser open = new JFileChooser();
   open.setFileFilter( new ClassFilter() );
   
   if( open.showOpenDialog( this ) == JFileChooser.APPROVE_OPTION )
   {
    fileToSend = open.getSelectedFile();
    
    if( !fileToSend.exists() )
    {
     JOptionPane.showMessageDialog( this , "File does not exist!" ,
        "Warnning!" , JOptionPane.WARNING_MESSAGE, null);
      return;
    }
    
    PathText.setText( fileToSend.getPath());
    if( !AcceptBtn.isEnabled() )
    {
     AcceptBtn.setEnabled(true);
    }
    
   }
  }
  else if( e.getActionCommand().equals("Accept"))
  {
   try
   {
    Socket client = sock.accept();
    FileInputStream fin = new FileInputStream( fileToSend );
    BufferedInputStream bin = new BufferedInputStream( fin );
    BufferedOutputStream bout = new BufferedOutputStream(client.getOutputStream());
    
    int b;
    while( (b=bin.read())!=-1 )
    {
     bout.write(b);
    }
    bin.close();
    bout.close();
    
    JOptionPane.showMessageDialog( this , "Finished!" );
   }
   catch(Exception ex)
   {
    JOptionPane.showMessageDialog( this , ex.getMessage() );
   }
  }
 }

 public static void main(String [] args )throws Exception
 {
  new ServerClassGiver(80);
 }
}

 

客户端：
ClassLoaderTest.java

import java.util.*;
import java.io.*;
import java.net.*;
import java.util.regex.*;

// Client
public class ClassLoaderTest extends ClassLoader
{
 private String IPAddr = null;
 private int port;
 
 public ClassLoaderTest( String ip , int port )
 {
  ip = ip.trim();
  Pattern ptn = Pattern.compile("//d+.//d+.//d+.//d+");
  Matcher mtc = ptn.matcher(ip);
  if( !mtc.matches() || port > 65535 || port <= 0)
  {
   throw new IllegalArgumentException("Argument Error!");
  }
  
  IPAddr = ip;
  this.port = port;
  
 }
 
 protected Class findClass( String Name ) throws ClassNotFoundException
 {
  try
  {
   Socket sock = new Socket( IPAddr , port );
   InputStream sin = sock.getInputStream();
   BufferedInputStream bin = new BufferedInputStream( sin );
   ByteArrayOutputStream baout = new ByteArrayOutputStream();
   
   int b;
   while(  (b=bin.read()) != -1 )
   {
    baout.write(b);
   }
   
   byte[] bts = baout.toByteArray();
   
   bin.close();
   baout.close();
   
   return defineClass( Name , bts , 0 , bts.length );
  }
  catch(Exception e )
  {
   return null;
  }
 }
 
 
 public static void main(String [] args)throws Exception
 {
  ClassLoaderTest ldr = new ClassLoaderTest("162.105.81.165",80);
  Class cls = ldr.loadClass("ClassFilter");
  System.out.println(cls.getName());
  System.out.println(cls.getClassLoader().getClass().getName());
 }
 
}