多级缓存原理

反射

类存储结构和反射

反射（Reflection）是 Java 的高级特性之一，是框架实现的基础。
定义：Java 反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；这种动态获取的信息以及动态调用对象的方法的功能称为 Java 语言的反射机制。
反射是对类元属性的封装，支持运行时访问和修改类属性，包括从 Class 中获取信息、创建对象、调用方法、访问属性值等。
说到类就不得不提类的加载过程，类是方法区中的一个数据结构，创建类时首先由类加载器读入字节码，然后进行验证、分配内存和初始化等过程，每个类加载器都有其命名空间，用于保存类结构，反射就是对这个类的结构的访问接口。
一般而言，当用户使用一个类的时候，应该获取这个类，而后通过这个类实例化对象，但是使用反射则可以相反的通过对象获取类中的信息。
通俗的讲反射就是可以在程序运行的时候动态装载类，查看类的信息，生成对象，或操作生成的对象。它允许运行中的 Java 程序获取自身的信息，自己能看到自己，就像照镜子一样。
另外，为什么要有反射这个“后门”呢？首先我们要区分静态和动态编译的概念：

• 静态编译：在编译时确定类型，绑定对象
• 动态编译：运行时确定类型，绑定对象
  两者的区别在于，动态编译可以最大程度地支持多态，多态最大的意义在于降低类的耦合性，而 Java 语言确是静态编译（如：int a=3；要指定类型），Java 反射很大程度上弥补了这一不足：解耦以及提高代码的灵活性，所以 Java 也被称为是准动态语言。
  尽管反射有诸多优点，但是反射也有缺点：

1. 由于反射会额外消耗一定的系统资源，因此，反射操作的效率要比那些非反射操作低得多。
2. 由于反射允许代码执行一些在正常情况下不被允许的操作（比如访问私有的属性和方法），所以使用反射可能会导致意料之外的副作用（代码有功能上的错误）。所以能用其它方式实现的就尽量不去用反射。

获取类信息

Class 没有公共构造方法。Class 对象是在加载类时由 Java 虚拟机以及通过调用类加载器中的 defineClass 方法自动构造的。也就是这不需要我们自己去处理创建，JVM 已经帮我们创建好了。
如果知道一个实例，那么可以通过实例的“getClass()”方法获得运行实例的 Class（该类型的字节码文件对象），如果你知道一个类型，那么你也可以使用“.class”的方法获得运行实例的 Class。
一般获取 Class 的方法有三种：

// 方式1：通过 Class 类的静态方法获取 Class 类对象 (推荐)
Class c = Class.forName("java.util.List");
// 方式2：因为所有类都继承 Object 类。因而可通过调用 Object 类中的 getClass 方法来获取
Object o = new Object();
o.getClass();
// 方式3：任何数据类型（包括基本数据类型）都有一个“静态”的 class 属性
Class c = Object.class;

以下示例中，obj 表示要解析的对象实例，clazz 表示获取到的该对象对应的字节码，用于分析包、类等信息

// 1 通过对象得到java的字节码
Class clazz = obj.getClass();
// clazz对象是 java内存的对象的字节码
// 2通过字节码获取包名
Package pk = clazz.getPackage();
String pname = pk.getName();
// demo.neusoft.po
System.out.println("该类包：" + pname);
// 3通过字节码对象得到类的全路径
String fullpath = clazz.getName();
System.out.println("类全路径：" + fullpath);
// 4通过字节码对象得到类的名字
String simpleName = clazz.getSimpleName();
System.out.println("类名：" + simpleName);
// 5通过字节码对象得到类的父类
Class fatherClazz = clazz.getSuperclass();
System.out.println(simpleName + "类的父类：" + fatherClazz.getSimpleName());
// 6通过字节码对象得到类的接口
Class[] interfaces = clazz.getInterfaces();
for (Class iclazz : interfaces) {
    System.out.println(simpleName + "类的接口：" + iclazz.getName());
}
// 7返回表示数组组件类型的 Class。如果此类是数组则返回表示此类组件类型的Class，如果此类不表示数组类，则此方法返回 null
Object[] o = new Object[4];
Class<?> componentType = o.getClass().getComponentType();

获取类加载器

返回该类的类加载器。有些实现可能使用 null 来表示引导类加载器，如果该类由引导类加载器加载，则此方法在这类实现中将返回 null，比如 Object。

//1、获取一个系统的类加载器
ClassLoader classLoader = ClassLoader.getSystemClassLoader();
System.out.println("系统的类加载器-->" + classLoader);
//2、获取系统类加载器的父类加载器(扩展类加载器（extensions classLoader）)
classLoader = classLoader.getParent();
System.out.println("扩展类加载器-->" + classLoader);
//3、获取扩展类加载器的父类加载器
//输出为Null,引导类加载器无法被Java程序直接引用
classLoader = classLoader.getParent();
System.out.println("启动类加载器-->" + classLoader);
//4、测试当前类由哪个类加载器进行加载 ,结果就是系统的类加载器
classLoader = Class.forName("com.tallate.repackage_2018.reflect.ClassTest").getClassLoader();
System.out.println("当前类由哪个类加载器进行加载-->"+classLoader);
//5、测试JDK提供的Object类由哪个类加载器负责加载的
classLoader = Class.forName("java.lang.Object").getClassLoader();
System.out.println("JDK提供的Object类由哪个类加载器加载-->" + classLoader);

如果存在安全管理器，并且调用者的类加载器不是 null，也不同于或是请求其类加载器的类的类加载器的祖先，则此方法通过 RuntimePermission(“getClassLoader”)权限调用此安全管理器 checkPermission 方法，以确保可以访问该类的类加载器。如果此对象表示一个基本类型或 void，则返回 null。

实例化对象

可能会抛出 InstantiationException 异常

Object newObj =null;
// 7.通过字节码对象实例化一个对象
newObj = clazz.newInstance();//相当于按类实例化一个对象
System.out.println("比较参数对象："+newObj==obj);
// 8.通过全路径实例化对象
Class<?> newObj2 = Class.forName(fullpath);
System.out.println("比较全路径对象："+newObj2==obj);

分析属性

// 9.通过字节码对象 分析属性
Field[] fields = clazz.getFields();//得到非私有属性
fields=clazz.getDeclaredFields();//获取私有属性
for (Field f : fields) {
    //获取属性名
    String fname = f.getName();
    //属性的类型
    Class type = f.getType();
    //针对私有属性的访问，临时放开权限
    f.setAccessible(true);
    //获取属性的值
    Object fval = f.get(obj);//get方法获取内存中的值，参数要求
    //针对属性设置
    //set(当前对象本身,属性设置的值);
    //f.set(newObj, value);
    //将当前对象的内存传递过来
    System.out.println("属性名称："+fname+
            ",属性类型"+type.getSimpleName()+
            ",属性值："+fval);
}

分析方法

// 10.通过字节码文件得到当前类的方法
//clazz.getMethod(name, parameterTypes)
Method[] methods = clazz.getMethods(); // 只获取public的
methods=clazz.getDeclaredMethods(); // 获取全部
for (Method method : methods) {
//分析方法结构
//得到方法返回类型
Class<?> returnType = method.getReturnType();
//方法名称
String name = method.getName();
//方法中参数类型集合
Class<?>[] pts = method.getParameterTypes();
String s="";
for (Class<?> pclazz : pts) {
String ptype = pclazz.getSimpleName();
   s=s+ptype+",";
}
System.out.println("方法返回类型："+returnType+
   "方法名:"+name+
   "方法参数类型："+s);
}
// 11.方法反射执行
//A：得到指定名称的方法对象的声明
Method method = clazz.getMethod("getStuname");
//B: 通过方法对象反射执行
//invoke(方法的当前对象本身,方法执行需要的实际参数)
Object val = method.invoke(obj);
System.out.println("getStuname方法返回："+val);
// 12.通过字节码对象得到构造方法
Constructor[] constructors = clazz.getConstructors();
for (Constructor constructor : constructors) {
//得到构造器的名称
String name = constructor.getName();
Class[] cps = constructor.getParameterTypes();
//构造器的反射执行
//constructor.newInstance(initargs)
}

*** 例子

1. 这个例子通过反射实例化一个 MyIOC 类，然后找到它类型为 AttributeType 的成员变量，然后调用对应的 setter 方法设置属性

   public static String toUpperStr(String str) {
       return Character.toUpperCase(str.charAt(0)) + str.substring(1);
   }
   public static void main(String[] args) {
       try {
           Class c = Class.forName("MyIOC");
           Object o = c.newInstance();
           Field[] declaredFields = c.getDeclaredFields();
           for (Field f : declaredFields) {
               if (f.getType() == AttributeType.class) {
                   Method set = c.getDeclaredMethod("set"
                           + toUpperStr(f.getName()), AttributeType.class);
                   set.invoke(o, new AttributeType("Hello"));
               }
           }
       } catch(Exception e) {
           e.printStackTrace();
       }
   }

绕过 private、final 限制

Field field = getField(target, fieldName);
// 设置private可访问
field.setAccessible(true);
// 设置final可修改
Field modifierField = Field.class.getDeclaredField("modifiers");
modifierField.setAccessible(true);
modifierField.setInt(field, field.getModifiers() & ~Modifier.FINAL);
field.set(target, value);

越过范型检查

泛型作用在编译期，编译过后泛型擦除（消失掉）。所以是可以通过反射越过泛型检查的。

public static void test10() throws Exception{
    ArrayList<Integer> list = new ArrayList<Integer>();
    list.add(100);
    list.add(200);
    Method method = list.getClass().getMethod("add", Object.class);
    method.invoke(list, "Java反射机制实例。");
    //遍历集合  
    for(Object obj : list){  
        System.out.println(obj);  
    }
}

通过反射机制获得数组信息并修改数组的大小和值

下面的方法可以扩展数组到新的长度。

public Object arrayInc(Object oldArr, int newLen) {
  Class<?> arr = oldArr.getClass().getComponentType();
  Object newArr = Array.newInstance(arr, newLen);
  int originLength = Array.getLength(oldArr);
  System.arraycopy(oldArr, 0, newArr, 0, originLength);
  return newArr;
}

下面的代码通过反射来修改数组某一位置的值。

Array.set(arr, 0, 100);

反射应用于工厂模式

平时在使用数据库的时候我们一般都需要在配置文件中设置所需的驱动器类，实际上就是应用了工厂模式，比如如果需要使用 MySQL 数据库：

driver=com.mysql.jdbc.Driver
```
### 使用反射实现简易ORM框架
#### 属性声明

public class BaseDao {
private Connection con;
private PreparedStatement pstm;
private ResultSet rs;
// 连接的一些属性
private String driver;
private String url;
private String uname;
private String pwd;
…
}

静态块加载连接属性

static {
Properties p = new Properties();
try {
FileInputStream rd = new FileInputStream(“db.properties”);
p.load(rd);
} catch(IOException e) {
e.printStackTrace();
}
driver = p.getProperty(“driver”);
url = p.getProperty(“url”);
name = p.getProperty(“name”);
pwd = p.getProperty(“pwd”);
}

#### 提取访问数据库的公共代码

private Object run(IDao idao,String sql,Object…objs){
Object obj=null;//执行 CRUD 返回的具体值
try {
// 1.提取 CRUD 中重复代码
Class.forName(driver);
con = DriverManager.getConnection(url, uname, pwd);
pstm = con.prepareStatement(sql);
// 2.为 sql 语句中问号赋值
for (int i = 0; i < objs.length; i++) {
pstm.setObject(i + 1, objs[i]);
}
// 3.利用第一个参数提供 crud 模板对象，执行具体的 crud 并返回结果
obj=idao.init(pstm);
} catch (ClassNotFoundException e) {
e.printStackTrace();
} catch (SQLException e) {
e.printStackTrace();
}finally{
try {
if(rs!=null)
rs.close();
if (pstm != null)
pstm.close();
if (con != null)
con.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
return obj;
}

其中IDao是数据库操作的回调接口

public interface IDao {
public Object init(PreparedStatement pstm)throws SQLException;
}

#### 插入和更新操作

public int saveOrUpdate(String sql, Object… objs) {
return (Integer) run(new IDao() {
@Override
public Object init(PreparedStatement pstm) throws SQLException {
return pstm.executeUpdate();
}
},sql,objs);
}

#### 查询操作
首先定义我们的数据库表和字段注解，数据库中对应的名字由注解给出

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
public @interface Xtable {
String value();
}
enum Genor {
Auto
}
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.FIELD)
public @interface Xid {
String value();
//主键生成方式
Genor Gen();
}

定义基础查询方法

List