反射？

类的加载过程：

1.如何创建Class的实例(重点)

1.1过程：源文件经过编译(javac.exe)以后，得到一个或多个.class文件。.class文件经过运行(java.exe)这步， 就需要进行类的加载（通过JVM的类的加载器），记载到内存中的缓存。每一个放入缓存中的.class文件就是一个Class的实例！

1.2 Class的一个对象，对应着一个运行时类。相当于一个运行时类本身充当了Class的一个实例。

1.3 java.lang.Class是反射的源头。 接下来涉及到反射的类都在java.lang.reflect子包下。如：Field Method Constructor Type Package.. 当通过Class的实例调用getMethods() —>Method , getConstructors() —->Constructor

1.4实例化Class的方法(三种):

// 1.调用运行时类的.class属性 Class clazz1 = Person.class; System.out.println(clazz1); Class clazz2 = Creator.class; System.out.println(clazz2); // 2.通过运行时类的对象，调用其getClass()方法 Person p = new Person(); Class clazz3 = p.getClass(); System.out.println(clazz3); // 3.调用Class的静态方法forName(String className)。此方法报ClassNotFoundException String className = "com.atguigu.java.Person"; Class clazz4 = Class.forName(className); System.out.println(clazz4);

2.Class的实例–应用一

应用一：可以创建对应的运行时类的对象(重点)

//获取运行时类的对象：方法一 @Test public void test1() throws Exception{ Class clazz = Class.forName("com.atguigu.review.Animal"); Object obj = clazz.newInstance(); Animal a = (Animal)obj; System.out.println(a); } //调用指定的构造器创建运行时类的对象 @Test public void test2() throws Exception{ Class clazz = Animal.class; Constructor cons = clazz.getDeclaredConstructor(String.class,int.class); cons.setAccessible(true); Animal a = (Animal)cons.newInstance("Tom",10); System.out.println(a); }

3.Class的实例–应用二

应用二：获取对应的运行时类的完整的类的结构：属性、方法、构造器、包、父类、接口、泛型、注解、异常、内部类。。。

如：Method[] m1 = clazz.getMethods() :获取到对应的运行时类中声明的权限为public的方法（包含其父类中的声明的public） Method[] m2 = clazz.getDeclaredMethods()：获取到对应的运行时类中声明的所有的方法（①任何权限修饰符修饰的都能获取②不含父类中的）

4.Class的实例–应用三

应用三：调用对应的运行时类中指定的结构（某个指定的属性、方法、构造器）(重点)

//调用指定属性 @Test public void test3() throws Exception{ Class clazz = Class.forName("com.atguigu.review.Animal"); Object obj = clazz.newInstance(); Animal a = (Animal)obj; //调用非public的属性 Field f1 = clazz.getDeclaredField("name"); f1.setAccessible(true); f1.set(a, "Jerry"); //调用public的属性 Field f2 = clazz.getField("age"); f2.set(a, 9); System.out.println(f2.get(a)); System.out.println(a); //调用static的属性 Field f3 = clazz.getDeclaredField("desc"); System.out.println(f3.get(null)); } //调用指定的方法 @Test public void test4() throws Exception{ Class clazz = Class.forName("com.atguigu.review.Animal"); Object obj = clazz.newInstance(); Animal a = (Animal)obj; //调用非public的方法 Method m1 = clazz.getDeclaredMethod("getAge"); m1.setAccessible(true); int age = (Integer)m1.invoke(a); System.out.println(age); //调用public的方法 Method m2 = clazz.getMethod("show", String.class); Object returnVal = m2.invoke(a,"金毛"); System.out.println(returnVal); //调用static的方法 Method m3 = clazz.getDeclaredMethod("info"); m3.setAccessible(true); // m3.invoke(Animal.class); m3.invoke(null); }

5.动态代理—反射的应用

体会反射的动态性 代理设计模式的原理:

使用一个代理将对象包装起来, 然后用该代理对象取代原始对象. 任何对原始对象的调用都要通过代理. 代理对象决定是否以及何时 将方法调用转到原始对象上

静态代理：要求被代理类和代理类同时实现相应的一套接口；通过代理类的对象调用重写接口的方法时，实际上执行的是被代理类的同样的 方法的调用。 静态代理模式

//静态代理模式 //接口 interface ClothFactory { void productCloth(); } // 被代理类 class NikeColthFactory implements ClothFactory { @Override public void productCloth() { System.out.println("Nike工厂生产了一批衣服"); } } // 代理类 class ProxFactory implements ClothFactory { ClothFactory cf; public ProxFactory(ClothFactory cf) { this.cf = cf; } @Override public void productCloth() { System.out.println("代理类开始执行，收代理费$1000"); cf.productCloth(); } } public class TestClothProduct { public static void main(String[] args) { NikeColthFactory nike = new NikeColthFactory();// 创建被代理类的对象 ProxFactory prxoy = new ProxFactory(nike);// 创建代理类的对象 prxoy.productCloth(); } }

动态代理：在程序运行时，根据被代理类及其实现的接口，动态的创建一个代理类。当调用代理类的实现的抽象方法时，就发起对被代理类同样 方法的调用。 涉及到的技术点：①提供一个实现了InvocationHandler接口实现类，并重写其invoke()方法 ②Proxy.newProxyInstance(obj.getClass().getClassLoader(),obj.getClass().getInterfaces(),h); 注：obj：被代理类对象 ； h:实现了InvocationHandler接口的实现类的对象 动态代理的使用

//动态代理的使用，体会反射是动态语言的关键 interface Subject { void action(); } // 被代理类 class RealSubject implements Subject { public void action() { System.out.println("我是被代理类，记得要执行我哦！么么~~"); } } class MyInvocationHandler implements InvocationHandler { Object obj;// 实现了接口的被代理类的对象的声明 // ①给被代理的对象实例化②返回一个代理类的对象 public Object blind(Object obj) { this.obj = obj; return Proxy.newProxyInstance(obj.getClass().getClassLoader(), obj .getClass().getInterfaces(), this); } //当通过代理类的对象发起对被重写的方法的调用时，都会转换为对如下的invoke方法的调用 @Override public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { //method方法的返回值时returnVal Object returnVal = method.invoke(obj, args); return returnVal; } } public class TestProxy { public static void main(String[] args) { //1.被代理类的对象 RealSubject real = new RealSubject(); //2.创建一个实现了InvacationHandler接口的类的对象 MyInvocationHandler handler = new MyInvocationHandler(); //3.调用blind()方法，动态的返回一个同样实现了real所在类实现的接口Subject的代理类的对象。 Object obj = handler.blind(real); Subject sub = (Subject)obj;//此时sub就是代理类的对象 sub.action();//转到对InvacationHandler接口的实现类的invoke()方法的调用 //再举一例 NikeClothFactory nike = new NikeClothFactory(); ClothFactory proxyCloth = (ClothFactory)handler.blind(nike);//proxyCloth即为代理类的对象 proxyCloth.productCloth(); } }

动态代理与AOP

interface Human { void info(); void fly(); } // 被代理类 class SuperMan implements Human { public void info() { System.out.println("我是超人！我怕谁！"); } public void fly() { System.out.println("I believe I can fly!"); } } class HumanUtil { public void method1() { System.out.println("=======方法一======="); } public void method2() { System.out.println("=======方法二======="); } } class MyInvocationHandler implements InvocationHandler { Object obj;// 被代理类对象的声明 public void setObject(Object obj) { this.obj = obj; } @Override public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { HumanUtil h = new HumanUtil(); h.method1(); Object returnVal = method.invoke(obj, args); h.method2(); return returnVal; } } class MyProxy { // 动态的创建一个代理类的对象 public static Object getProxyInstance(Object obj) { MyInvocationHandler handler = new MyInvocationHandler(); handler.setObject(obj); return Proxy.newProxyInstance(obj.getClass().getClassLoader(), obj .getClass().getInterfaces(), handler); } } public class TestAOP { public static void main(String[] args) { SuperMan man = new SuperMan();//创建一个被代理类的对象 Object obj = MyProxy.getProxyInstance(man);//返回一个代理类的对象 Human hu = (Human)obj; hu.info();//通过代理类的对象调用重写的抽象方法 System.out.println(); hu.fly(); //********* NikeClothFactory nike = new NikeClothFactory(); Object obj1 = MyProxy.getProxyInstance(nike); ClothFactory cloth = (ClothFactory)obj1; cloth.productCloth(); } }

效果：

---

反射例子

public class TestReflection { //调用指定的方法 @Test public void test4() throws Exception{ Class clazz = Class.forName("com.atguigu.review.Animal"); Object obj = clazz.newInstance(); Animal a = (Animal)obj; //调用非public的方法 Method m1 = clazz.getDeclaredMethod("getAge"); m1.setAccessible(true); int age = (Integer)m1.invoke(a); System.out.println(age); //调用public的方法 Method m2 = clazz.getMethod("show", String.class); Object returnVal = m2.invoke(a,"金毛"); System.out.println(returnVal); //调用static的方法 Method m3 = clazz.getDeclaredMethod("info"); m3.setAccessible(true); // m3.invoke(Animal.class); m3.invoke(null); } //调用指定属性 @Test public void test3() throws Exception{ Class clazz = Class.forName("com.atguigu.review.Animal"); Object obj = clazz.newInstance(); Animal a = (Animal)obj; //调用非public的属性 Field f1 = clazz.getDeclaredField("name"); f1.setAccessible(true); f1.set(a, "Jerry"); //调用public的属性 Field f2 = clazz.getField("age"); f2.set(a, 9);` System.out.println(f2.get(a)); System.out.println(a); //调用static的属性 Field f3 = clazz.getDeclaredField("desc"); System.out.println(f3.get(null)); } //调用指定的构造器创建运行时类的对象 @Test public void test2() throws Exception{ Class clazz = Animal.class; Constructor cons = clazz.getDeclaredConstructor(String.class,int.class); cons.setAccessible(true); Animal a = (Animal)cons.newInstance("Tom",10); System.out.println(a); } //获取运行时类的对象：方法一 @Test public void test1() throws Exception{ Class clazz = Class.forName("com.atguigu.review.Animal"); Object obj = clazz.newInstance(); Animal a = (Animal)obj; System.out.println(a); } }

如何获取：

public class TestReflection { //关于类的加载器：ClassLoader @Test public void test5() throws Exception{ ClassLoader loader1 = ClassLoader.getSystemClassLoader(); System.out.println(loader1); ClassLoader loader2 = loader1.getParent(); System.out.println(loader2); ClassLoader loader3 = loader2.getParent(); System.out.println(loader3); Class clazz1 = Person.class; ClassLoader loader4 = clazz1.getClassLoader(); System.out.println(loader4); String className = "java.lang.String"; Class clazz2 = Class.forName(className); ClassLoader loader5 = clazz2.getClassLoader(); System.out.println(loader5); //掌握如下 //法一： ClassLoader loader = this.getClass().getClassLoader(); InputStream is = loader.getResourceAsStream("com\\atguigu\\java\\jdbc.properties"); //法二： // FileInputStream is = new FileInputStream(new File("jdbc1.properties")); Properties pros = new Properties(); pros.load(is); String name = pros.getProperty("user"); System.out.println(name); String password = pros.getProperty("password"); System.out.println(password); } //如何获取Class的实例（3种） @Test public void test4() throws ClassNotFoundException{ //1.调用运行时类本身的.class属性 Class clazz1 = Person.class; System.out.println(clazz1.getName()); Class clazz2 = String.class; System.out.println(clazz2.getName()); //2.通过运行时类的对象获取 Person p = new Person(); Class clazz3 = p.getClass(); System.out.println(clazz3.getName()); //3.通过Class的静态方法获取.通过此方式，体会一下，反射的动态性。 String className = "com.atguigu.java.Person"; Class clazz4 = Class.forName(className); // clazz4.newInstance(); System.out.println(clazz4.getName()); //4.（了解）通过类的加载器 ClassLoader classLoader = this.getClass().getClassLoader(); Class clazz5 = classLoader.loadClass(className); System.out.println(clazz5.getName()); System.out.println(clazz1 == clazz3);//true System.out.println(clazz1 == clazz4);//true System.out.println(clazz1 == clazz5);//true } /* * java.lang.Class:是反射的源头。 * 我们创建了一个类，通过编译（javac.exe）,生成对应的.class文件。之后我们使用java.exe加载（JVM的类加载器完成的） * 此.class文件，此.class文件加载到内存以后，就是一个运行时类，存在在缓存区。那么这个运行时类本身就是一个Class的实例！ * 1.每一个运行时类只加载一次！ * 2.有了Class的实例以后，我们才可以进行如下的操作： * 1）*创建对应的运行时类的对象 * 2）获取对应的运行时类的完整结构（属性、方法、构造器、内部类、父类、所在的包、异常、注解、...） * 3）*调用对应的运行时类的指定的结构(属性、方法、构造器) * 4）反射的应用：动态代理 */ @Test public void test3(){ Person p = new Person(); Class clazz = p.getClass();//通过运行时类的对象，调用其getClass()，返回其运行时类。 System.out.println(clazz); } //有了反射，可以通过反射创建一个类的对象，并调用其中的结构 @Test public void test2() throws Exception{ Class clazz = Person.class; // Class clazz1 = String.class; //1.创建clazz对应的运行时类Person类的对象 Person p = (Person)clazz.newInstance(); System.out.println(p); //2.通过反射调用运行时类的指定的属性 //2.1 Field f1 = clazz.getField("name"); f1.set(p,"LiuDeHua"); System.out.println(p); //2.2 Field f2 = clazz.getDeclaredField("age"); f2.setAccessible(true); f2.set(p, 20); System.out.println(p); //3.通过反射调用运行时类的指定的方法 Method m1 = clazz.getMethod("show"); m1.invoke(p); Method m2 = clazz.getMethod("display",String.class); m2.invoke(p,"CHN"); } //在有反射以前，如何创建一个类的对象，并调用其中的方法、属性 @Test public void test1(){ Person p = new Person(); // Person p1 = new Person(); p.setAge(10); p.setName("TangWei"); System.out.println(p); p.show(); // p.display("HK"); } }