本文是根据李刚的《疯狂讲义》作的笔记，程序有的地方做了修改，特别是路径，一直在混淆，浪费了好多时间！！希望懂的同学能够指导本人，感激尽。。。。。。。。。。。。
1.jvm 和 类的关系
当调用 java命令运行一个java程序时，必会启动一个jvm即java虚拟机。(5.6.处有联系！！)
该java程序的所有线程，变量都处于jvm中，都使用该jvm的内存区
jvm终止的情况：
1.程序自然运行结束
2.遇到System.exit();Runtime.getRuntime.exit();
3.遇到未捕获异常或错误时
4.程序所在的平台强制结束了JVM进程
jvm终止，jvm内存中的数据全部丢失。
举例：
定义一个类，包含静态变量
class AClass{
public static int a = 1;
}
使变量自加
public class ATest {
public static void main(String[] args) {
AClass a = new AClass();
a.a++;
System.out.println("a的值："+a.a);//输出：a的值：2
}
}
另起一类，查看变量变化情况
public class ATest2 {
public static void main(String[] args) {
AClass a = new AClass();
System.out.println("a的值："+a.a);//输出：a的值：1
}
}
从输出对比可知，虽然ATest1自加，改变的类变量a的值，但是ATest1与ATest2处于不用的JVM中，当ATest1结束时，对a的修改都丢失了
2.类的加载
类的加载 又称为 类的初始化，实际上可细分为 类的 加载、连接、初始化。下面将讲述着三个阶段的过程!
类的加载 指.class文件读入内存，并为之创建一个 java.lang.Class对象
类加载，是通过类加载器来完成的，类加载器通常由JVM提供，通常称为系统类加载器（也可以是自己写的加载器，只要继承ClassLoader基类）。
类加载无须等到“首次使用该类”时加载，jvm允许预加载某些类。。。。
加载来源：
1.本地.class文件
2.jar包的.class文件
3.网络.class文件
4.把一个java源文件动态编译，加载
3.类的连接
负责把类的二进制数据合并到JRE（java运行环境）中
1.验证 检测被加载的类是否有正确的内部结构，并和其他类协调一致
2.准备 负责为类的类变量（非对象变量）分配内存，并设置默认初始值
3.解析 将类的二进制数据中的符号引用替换成直接引用。。(static final 好像跟这个有点关系？？？？5.6.处有联系）
4.类初始化
主要对类变量（而非对象变量）的初始化
声明类变量的初始值 = 静态初始化块 他们是相同的，等效的。都会被当成类的初始化语句，JVM会按照这些语句在程序中的顺序依次执行他们
public class Test {
static int a = 5; //初始化时赋值
static int b; //初始化时赋值--静态块
static int c; //连接时赋默认值值
static{
b = 6;
}
public static void main(String[] args) {
System.out.println(a);
System.out.println(b);
System.out.println(c);
}
输出：
5
6
0
JVM初始化一个类包含如下几个步骤：
1.假设类还没有被加载和连接，那么先加载和连接该类
2.假设该类的父类还没被初始化，那么先初始化父类 ----jvm总是最先初始化java.lang.Object类
3.假设类中有初始化语句，则一次执行这些初始化语句
当程序主动使用任何一个类时，系统会保证该类以及所有父类（直接父类和间接父类）都会被初始化
5.类初始化的时机：
1.创建类的实例。new,反射，反序列化
2.使用某类的类方法--静态方法
3.访问某类的类变量，或赋值类变量
4.反射创建某类或接口的Class对象。Class.forName("Hello");---注意：loadClass调用ClassLoader.loadClass(name,false)方法,没有link，自然没有initialize
5.初始化某类的子类
6.直接使用java.exe来运行某个主类。即cmd java 程序会先初始化该类。
特殊情形：final 类型的类变量，如果在编译时（转成.class文件）就可以确定，那么这个类变量就相当于“宏变量”，编译时，直接替换成值。
所以，即使使用这个类变量，程序也不会导致该类的初始化！！----相当于直接使用 常量
public class Test {
public static void main(String[] args) {
System.out.println(aClass.A);
}
}
class aClass{
static final int A = 111;//可以确定
static{
System.out.println("静态块初始化");
}
}
输出：111
public class Test {
public static void main(String[] args) {
System.out.println(aClass.A);
}
}
class aClass{
static final long A = System.currentTimeMillis();//在编译时无法确定
static{
System.out.println("静态块初始化");
}
}
输出：
静态块初始化
1468309845203
使用ClassLoader类的 loadClass方法来加载类时，只是加载该类，而不会执行该类的初始化！！使用Class的forName()静态方法，才会导致强制初始化该类。
6.类加载器
类加载器 负责加载所有的类，为被加载如内存中的类生成一个java.lang.Class实例。一旦类被载入内存，同一个类就不会再加载第二次
如何判断是同一个类：
java中 一个类用其 全限定类名标示--包名+类名
jvm中 一个类用其 全限定类名+加载器标示---包名+类名+加载器名
加载器层次结构：
JVM启动时，姓曾的三个类加载器组成的机构
1.Bootstrap ClassLoader 根类 ------引导类加载器，加载java核心类。非java.lang.ClassLoader子类，而是JVM自身实现
2.Extension ClassLoader 扩展类-----加载JRE的扩展目录中的JAR包的类（%JAVA_HOME%/jre/lib/ext或java.ext.dirs系统属性指定的目录）
3.System ClassLoader 系统类-----加载cmd java -cp **,环境变量指定的jar包和类路径。ClassLoader.getSystemClassLoader获得 系统类加载器。
4.用户类加载器。。。
public class BootstrapTest {
public static void main(String[] args) {
// 获取根类加载器所加载的全部URL数组
URL[] urls = sun.misc.Launcher.getBootstrapClassPath().getURLs(); //无需理会警告
//遍历 输出根类加载器 加载的全部URL
for (int i = 0; i < urls.length; i++) {
System.out.println(urls[i].toExternalForm());
}
}
}
输出：
file:/C:/Program%20Files/Java/jre1.8.0_20/lib/resources.jar
file:/C:/Program%20Files/Java/jre1.8.0_20/lib/rt.jar
file:/C:/Program%20Files/Java/jre1.8.0_20/lib/sunrsasign.jar
file:/C:/Program%20Files/Java/jre1.8.0_20/lib/jsse.jar
file:/C:/Program%20Files/Java/jre1.8.0_20/lib/jce.jar
file:/C:/Program%20Files/Java/jre1.8.0_20/lib/charsets.jar
file:/C:/Program%20Files/Java/jre1.8.0_20/lib/jfr.jar
file:/C:/Program%20Files/Java/jre1.8.0_20/classes
7.类的加载机制：
1.全盘负责。某类以及其所依赖的所有类，都由一个加载器负责加载。除非显示使用另外一个加载器。
2.父类委托。先父类加载器加载改Class，不行后，才尝试从自己的类路径中加载该类
3.缓存机制。缓存机制将会保证所有加载过的Class都会被缓存。。当程序需要Class时，先从缓存区中寻找Class对象，没有的话，才加载该类的.class对象。
8.访问类加载器
public static void main(String[] args) throws IOException {
ClassLoader systemLoader = ClassLoader.getSystemClassLoader();// get system loader 获得系统的类加载器
System.out.println("系统类加载器: "+systemLoader);
/*
* 获取 系统类加载器 的加载路径--通常由CLASSPATH 环境变量 指定，
* 如果，操作系统 没有指定CLASSPATH环境变量， 则 默认以当前路径作为 系统类加载器 的家在路径
*/
Enumeration<URL> eml = systemLoader.getResources("");
while(eml.hasMoreElements()){
System.out.println("SYSTEMClassLoader Route: "+eml.nextElement());//系统类加载器的加载路径 是程序运行的当前路径
}
//获取 系统类加载器 的父类加载器，得到 扩展类加载器
ClassLoader extenionLoader = systemLoader.getParent();
System.out.println("扩展类加载器: "+extenionLoader);
System.out.println("扩展类加载器的 路径: "+System.getProperty("java.ext.dirs"));
ClassLoader baseLoader = extenionLoader.getParent();
System.out.println("扩展类加载器的 父类："+baseLoader);//The parent Classload is Bootstrap ClassLoader.BC is not use Java Language...So..
//根加载器 没有 继承ClassLoader抽象类。所以，返回的是Null
//但实际上 扩展类加载器 的 父类加载器 是 根类加载器，只是，根类加载器 并不是 java实现的。
}
输出：
系统类加载器: [email protected]
SYSTEMClassLoader Route: file:/D:/WorkSpace1/Java_Test/bin/
扩展类加载器: [email protected]
扩展类加载器的 路径: C:\Program Files\Java\jre1.8.0_20\lib\ext;C:\Windows\Sun\Java\lib\ext
扩展类加载器的 父类：null
系统类加载器是 AppClassLoader 的实例，扩展类加载器是 ExtClassLoader 的实例，这两个类都是 URLClassLoader 的实例
9，类加载器加载Class大致要经过9个步骤：
1.检测此Class 是否被载入过（即在缓存区中是否由此 Class），有，则进入第8步，否则执行第2步。
2.如果父类加载器不存在（要么parent 一定是根类加载器，要么本身就是根类加载器），则跳到第4步；如果父类加载器存在，则执行第3步。
3.请求使用父类加载器去载入目标类，如果成功则跳到第8步，否则执行第5步
4.请求使用 根类加载器 载入目标类，成功则跳到第8步，否则跳到第7步
5.当前类加载器 尝试寻找 Class文件（从与此ClassLoader相关的类路径中寻找），如果找到则执行第6步，否则跳到第7步。
6.从文件中载入Class，成功后跳到第8步。
7.抛出ClassNotFoundException异常。
8.返回对应的 java.lang.Class对象。
其中 第5,6步允许重写ClassLoader的findClass()方法来实现自己的载入策略，甚至重写loadClass()方法来实现自己 的载入过程
10.一个自定义的ClassLoader
由于是用eclipse编写程序，所以.java和.class文件分别放于不同的文件夹。写此程序的时候 要注意路径问题
本项目的包结构：
Java_Test|
|src |
|Chapter18|
| ClassloaderMineTest.java
| Test.java
项目路径：D:\WorkSpace1\Java_Test\bin; D:\WorkSpace1\Java_Test\src
/**
* 读取一个文件 的 内容，返回byte[]
* @param filename
* @return
* @throws IOException
*/
private byte[] getBytes(String filename) throws IOException {
System.out.println("使用getBytes方法");
File file = new File(filename);//路径 bin/Chapter18/Test.class
long len = file.length();
byte[] raw = new byte[(int)len];
try (FileInputStream fin = new FileInputStream(file)){
//一次读取Class文件的全部二进制数据
int r = fin.read(raw);
if(r!=len) throw new IOException("无法读取全部文件："+r+"!="+len);
return raw;
}
}
/**
* 编译指定JAVA文件，返回编译的结果
* @param javaFile
* @return
* @throws IOException
*/
private boolean compile(String javaFile) throws IOException{
System.out.println("myClassLoader:正在编译"+javaFile+"..........");
//调用系统的javac命令--指定了.class生成的路径，注意空格。此处为何不加上Chapter18呢？难道是java命名唯一性的缘故，包名+类名，已经知道了包名？？
Process p = Runtime.getRuntime().exec("javac -d d:/WorkSpace1/Java_Test/bin/ "+javaFile);
try {
//其他线程都等待这个线程完成
p.waitFor();
} catch (Exception e) {
// TODO: handle exception
System.out.println(e);
}
//获取javac线程的退出值
int ret = p.exitValue();
//返回编译是否成功 return res == 0;
}
/**
* 重写的findClass方法
*/
@Override
protected Class<?> findClass(String name) throws ClassNotFoundException {//name = Test
Class clazz = null;
String javaFilename = "src/Chapter18/"+fileStub+".java";
String classFilename = "bin/Chapter18/"+fileStub + ".class";
File javaFile = new File(javaFilename); //相对路径，相对于项目的跟路径：D:\WorkSpace1\Java_Test
File classFile = new File(classFilename);
//当指定Java源文件存在，且，Class文件不存在，或者Java源文件的修改时间比class文件的修改时间更晚时，重新编译if(javaFile.exists() && (!classFile.exists()||javaFile.lastModified()>classFile.lastModified())){
try {
//如果编译失败，或者该class文件不存在
if(!compile(javaFilename)||!classFile.exists()){
throw new ClassNotFoundException("ClassNotFoundException:"+javaFilename+ " or "+classFile+" is not exists");
}
} catch (Exception e) {
// TODO: handle exception
e.printStackTrace();
}
}
//如果class文件存在，系统负责将该文件转换成class对象
if(classFile.exists()){
try {
//将class文件的二进制数据读入数组
byte[] raw = getBytes(classFilename);
//调用ClassLoader的defineClass 方法将二进制数据转换成class对象
clazz = defineClass("Chapter18.Test",raw,0,raw.length);//路径 Chapter18.Test
} catch (Exception e) {
// TODO: handle exception
e.printStackTrace();
}
}
//如果clazz为null，表明加载失败，则抛出异常
if(clazz == null){
throw new ClassNotFoundException(name);
}
return clazz;
}
/**
* main方法
* @param args
* @throws Exception
*/
public static void main(String[] args) throws Exception {
ClassloaderMineTest mc = new ClassloaderMineTest();
Class<?> clazz1 = mc.findLoadedClass("Chapter18.Test");
Class<?> clazz = mc.loadClass("Test",false); //路径 Test?
Class<?> clazz2 = mc.findLoadedClass("Chapter18.Test"); //路径 Chapter18.Test？？,为什么又和loadClass的路径不一样呢
//得到Class对象后就可以反射了
Method main = clazz.getMethod("main", (new String[0].getClass()));
String[] progArgs = {"Chapter18.Test"};
Object argsArray[] = {progArgs};
main.invoke(null, argsArray);
}
11.URLClassLoader 类
java 为 ClassLoader 提供了一个 实现类 URLClassLoader ,该类 也是系统类加载器 和 扩展类加载器的 父类
URLClassLoader 的 两个构造器
URLClassLoader(URL[] urls)
URLClassLoader(URL[] urls, ClassLoader parent)
一旦 获得URLClassLoader对象后，就可以调用对象的 loadClass()方法 来加载指定的类。
下面展示的程序示范了如何直接从文件系统中加载MySQL驱动，并且使用该驱动来获取数据库连接。。通过这种方式，可以无须将MySQL驱动添加到CLASSPATH环境变量中
public class URLClassLoaderTest {
private static Connection conn;
private String url;
private String driver;
/**
* 获得该用户下面的所有表
*/
public static void getAllTableList(String schemaName,DatabaseMetaData dbMeta) {
try {
// table type. Typical types are "TABLE", "VIEW", "SYSTEM TABLE", "GLOBAL TEMPORARY", "LOCAL TEMPORARY", "ALIAS", "SYNONYM".
String[] types = { "TABLE" };
ResultSet rs = dbMeta.getTables(null, schemaName, "%", types);
while (rs.next()) {
String tableName = rs.getString("TABLE_NAME"); //表名
String tableType = rs.getString("TABLE_TYPE"); //表类型
String remarks = rs.getString("REMARKS"); //表备注
System.out.println(tableName + "-" + tableType + "-" + remarks);
}
} catch (SQLException e) {
e.printStackTrace();
}
}
//定义一个获取数据库 连接的方法
public static Connection getConn(String url,String user,String pass) throws Exception{
if(conn==null){
//file 表名是从 本地文件系统加载，
//http:为前缀，表明从互联网通过HTTP来访问
//注意 URL 路径
// URLClassLoader loader = new URLClassLoader(new URL[]{new URL("file:D:/WorkSpaceMyEclipse/Meeting_Hall/WebRoot/WEB-INF/classes/")});
URL[] urls = {new URL("file:mysql-connector-java-5.1.30-bin.jar")};//从本地加载,jar包由外界导入，或者是放在项目的跟路径D:\WorkSpace1\Java_Test
//以 默认的 ClassLoader 作为父 ClassLoader,创建 URLClassLoader
URLClassLoader myClassLoader = new URLClassLoader(urls);
//加载MYSQL的JDBC驱动， 并创建默认实例-------与 普通的通过 new 生成实例的方法 对比
Driver driver = (Driver)myClassLoader.loadClass("com.mysql.jdbc.Driver").newInstance();
//创建一个 设置JDBC连接属性的 Properties对象
Properties props = new Properties();
//至少需要为改对象传入 user和password两个属性
props.setProperty("user", user);
props.setProperty("password", pass);
//调用Driver 对象的 connect方法来取得数据库连接
conn = driver.connect(url, props);
}
return conn;
}
public static void main(String[] args) throws Exception {
getConn("jdbc:mysql://localhost:3306/user_login", "root", "root");
DatabaseMetaData dbMeta = conn.getMetaData();
// 获取表中索引信息
getAllTableList(null, dbMeta);
}
}
输出：
affair-TABLE-
comment-TABLE-
sort-TABLE-
user-TABLE-
/**
* 普通的 数据库连接方法
* @return
*/
public static Connection getDBConnection() {
try {
// 加载数据库
Class.forName("com.mysql.jdbc.Driver");
String url = "jdbc:mysql://localhost:3306/user_login";
String user = "root";
String password = "root";
// 连接
conn = DriverManager.getConnection(url, user, password);
} catch (Exception e) {
e.printStackTrace();
}
return conn;
}