赞
踩
1)编译过程:程序经过java.exe
命令以后,会生成一个或多个字节码文件(.class
文件)
2)类的加载过程:接着我们使用java.exe
命令对某个字节码文件进行解释运行,这就相当于将某个字节码文件加载到内存中。此过程就成为类的加载。加载到内存中的类,我们就成为运行时类,此时运行时类,就作为Class类的一个实例,换句话说,Class的实例就对应着一个运行时类。
3)Class类的实例:加载到内存中的运行时类,会缓存一定的时间。在此时间内,我们可以通过不同的方式来获取此运行时类。1.类(内部类,外部类)2.接口 3.数组 4.枚举类 5.注解 6.基本数据类型 7.void
1)Person类
package com.bjpowernode.ba01; public class Person { private String name; public int age; public String getName() { return name; } public void setName(String name) { this.name = name; } public int getAge() { return age; } public void setAge(int age) { this.age = age; } @Override public String toString() { return "Person{" + "name='" + name + '\'' + ", age=" + age + '}'; } public void show(){ System.out.println("你好,我是一个人"); } private String showNation(String nation){ System.out.println("我的国籍是:"+nation); return nation; } public Person(String name, int age) { this.name = name; this.age = age; } private Person(String name) { this.name = name; } public Person() { } }
2)测试代码
public class RelectTest { @Test public void test1() throws ClassNotFoundException { //方式一:调用运行时类的属性:.class Class clazz1 = Person.class; System.out.println(clazz1); //方式二:通过运行时类的对象,调用getClass() Person p1 = new Person(); Class clazz2 = p1.getClass(); System.out.println(clazz2); //方式三:调用Class的静态方法:forName(String classPath) Class clazz3 = Class.forName("com.bjpowernode.ba01.Person"); System.out.println(clazz3); //方式四:使用类的加载器:ClassLoader ClassLoader classLoader = RelectTest.class.getClassLoader(); Class clazz4 = classLoader.loadClass("com.bjpowernode.ba01.Person"); System.out.println(clazz4); System.out.println(clazz1==clazz2); } }
测试代码:
public class ClassLoaderTest { @Test public void test1(){ //对于自定义的类,使用类加载器进行加载 ClassLoader classLoader = ClassLoaderTest.class.getClassLoader(); System.out.println(classLoader); //调用系统类加载的getParent():获取扩展类加载器 ClassLoader classLoader1 = classLoader.getParent(); System.out.println(classLoader1); //调用扩展类加载器的getParent():无法获取引导类加载器 //引导类加载器主要负责加载java的核心类库,无法加载自定义类的,例如String类。 ClassLoader classLoader2 = classLoader1.getParent(); System.out.println(classLoader2); ClassLoader classLoader3 = String.class.getClassLoader(); System.out.println(classLoader3); } }
控制台输出:
使用ClassLoader加载配置文件:
public void test2() throws IOException {
Properties pros = new Properties();
ClassLoader classLoader = ClassLoaderTest.class.getClassLoader();
InputStream is = classLoader.getResourceAsStream("jdbc.properties");
pros.load(is);
String user = pros.getProperty("user");
}
}
注意:使用此方法加载配置文件时,配置文件必须在src
下,而不是在此moudle
下。
public class NewInstanceTest {
@Test
public void test() throws IllegalAccessException, InstantiationException {
//获取运行时类
Class<Person>clazz = Person.class;
//调用newInstance()方法创建运行时类的对象,底层还是使用运行时类的无参构造创建的对象。
Person person = clazz.newInstance();
System.out.println(person);
//InstantiationException:这个异常是没有该运行时类的无参构造,无法创建对象。
//IllegalAccessException:这个异常是无参构造没有访问权限,比如是private后的构造器,newInstance()也无法访问到。
}
}
注意:
InstantiationException
:这个异常是没有该运行时类的无参构造,无法创建对象。
IllegalAccessException
:这个异常是无参构造没有访问权限,比如是private
后的构造器,newInstance()
也无法访问到。
@Test public void test(){ Class clazz = Person.class; //获取属性结构 //getFields():获取当前运行时类及其父类中声明为public访问权限的属性 Field[] fields = clazz.getFields(); //declaredFields():获取当前运行时类中声明的所有属性。(不含父类中的属性) Field[] declaredFields = clazz.getDeclaredFields(); for(Field f : declaredFields){ //1.获取属性的权限修饰符 int modifier = f.getModifiers(); //2.获取属性的数据类型 Class type = f.getType(); //3.获取属性的变量名 String name = f.getName(); } }
@Test
public void text2(){
Class clazz = Person.class;
//getMethods():获取当前运行时类及其所有父类中声明为public权限的方法
Method[]methods = clazz.getMethods();
//getDeclaredMethods()获取当前运行时类中声明的所有方法(不包含父类中声明的方法)
Method[] declaredMethods = clazz.getDeclaredMethods();
}
@Test
public void text3(){
Class clazz = Person.class;
//getConstructors():获取当前运行时类及其所有父类中声明为public权限的构造器
Constructor[] constructors = clazz.getConstructors();
//getDeclaredConstructors():获取当前运行时类中声明的所有构造器
Constructor[] declaredConstructors = clazz.getDeclaredConstructors();
}
@Test
public void text4(){
Class clazz = Person.class;
Class superclass = clazz.getSuperclass();
System.out.println(superclass);
}
@Test
public void text5(){
Class clazz = Person.class;
//获取运行时类实现的接口
Class[] interfaces = clazz.getInterfaces();
//获取运行时类父类实现的接口
Class[] interfaces1 = clazz.getSuperclass().getInterfaces();
//获取运行时类所在的包
Package aPackage = clazz.getPackage();
//获取运行时类声明的注解
Annotation[] annotations = clazz.getAnnotations();
}
@Test
public void text() throws IllegalAccessException, InstantiationException, NoSuchFieldException {
Class clazz = Person.class;
//获取运行时类的对象
Person p = (Person)clazz.newInstance();
//获取指定的属性:要求运行时类中属性声明为public
Field id = clazz.getField("id");
//保证当前属性是可访问的
id.setAccessible(true);
//设置当前属性的值
id.set(p,1000);
//获取当前属性的值
Object o = id.get(p);
System.out.println(o);
}
@Test
public void text1() throws IllegalAccessException, InstantiationException, NoSuchFieldException, NoSuchMethodException, InvocationTargetException {
Class<Person> clazz = Person.class;
//获取运行时类的对象
Person p = clazz.newInstance();
//1.获取某个指定的方法,getDeclaredMethod()参数1:指明获取的方法名称
// 参数2:指明获取的方法的形参列表
Method show = clazz.getDeclaredMethod("showNation", String.class);
//2.保证当前方法是可以访问的
show.setAccessible(true);
//3.调用方法的invoke()参数1:方法的调用者 参数2:此方法的实参
Object returnvalue = show.invoke(p, "中国");
System.out.println(returnvalue);
}
换句话说,使用代理对象,是为了在不修改目标对象的基础上,增强主业务逻辑
客户类真正想要访问的对象是目标对象,但客户类真正可以访问的对象是代理对象。客户类对目标对象的访问是通过访问代理对象来实现的。当然,代理类与目标类要实现同一个接口。
例如:有A,B,C三个类,A原来可以调用C类的方法,现在因为某种原因C类不允许A类调用其方法,但B类可以调用C类的方法。A类通过B类调用C类的方法。这里B是C的代理。A通过代理B访问C。
1.功能增强:在你原有的功能上,增加了额外的功能,新增加的功能,叫做功能增强。
2.控制访问:代理类不让你访问目标,例如商家不让用户访问厂家。
1)代理类是自己手工实现的,自己创建一个java类,表示代理类。2)同时你所要代理的目标类是确定的。
举例:在淘宝上买U盘,淘宝中间商赚差价。
1、接口
package com.bjpowernode.service;
public interface UsbSell {
public float sell(int amount);
}
2、生产U盘的厂商
package com.bjpowernode.factory;
import com.bjpowernode.service.UsbSell;
public class UsbKingFactory implements UsbSell {
@Override
public float sell(int amount){
return 85.0f;
}
}
3、淘宝(中间代理商)
package com.bjpowernode.shangjia;
import com.bjpowernode.factory.UsbKingFactory;
import com.bjpowernode.service.UsbSell;
public class TaoBao implements UsbSell {
UsbKingFactory usbKingFactory = new UsbKingFactory();
@Override
public float sell(int amount) {
float price = usbKingFactory.sell(amount);
price = price+25;
return price;
}
}
4、用户购买
package com.bjpowernode;
import com.bjpowernode.shangjia.TaoBao;
public class ShopMain {
public static void main(String[] args) {
TaoBao taoBao = new TaoBao();
float price = taoBao.sell(1);
System.out.println(price);
}
}
1、动态代理优势:在静态代理中目标类很多的时候,可以使用动态代理,避免静态代理的缺点。静态代理中目标类即使很多。
1)代理类数量可以很少。2)当你修改了接口中的方法时,不会影响代理类。
2、动态代理:在程序执行的过程中,**使用jdk的反射机制,创建代理对象,**并动态的指定要代理的目标类。换句话说:**动态代理是一种创 建java对象的能力,**让你不用创建代理类(TaoBao类),就能创建代理类对象。
3、动态代理的实现:
1)jdk动态代理(理解):使用java反射包中的类和接口实现动态代理的功能,反射包 java.lang.reflect,里面有三个类:InvocationHandler,Method,Proxy
2)cglib动态代理(了解):cglib是第三方的工具库,创建代理对象。cglib的原理是继承,cglib通过继承目标类,创 建它的子类,在子类中重写父类中同名的方法,实现功能的修改。
由于cglib是继承、重写的方法,所以要求目标类不能是final的,方法也不能是final的。cglib的要求目标类比较松, 只要继承就可以了。cglib在很多的框架中使用,比如mybatis,spring框架中都有使用。
4、JDK动态代理(必须要有接口才能使用JDK动态代理)
1、创建接口,定义目标类要完成的功能
package com.bjpowernode.service;
public interface UsbSell {
float sell(int amount);
}
2、创建目标类实现接口
package com.bjpowernode.factory;
import com.bjpowernode.service.UsbSell;
public class UsbKingFactory implements UsbSell {
@Override
public float sell(int amount) {
//目标方法
System.out.println("目标类中,执行sell目标方法");
return 85.0f;
}
}
3、创建InvocationHandler接口的实现类,在invoke方法中完成代理类的功能
package com.bjpowernode.handler; import java.lang.reflect.InvocationHandler; import java.lang.reflect.Method; //必须实现InvocationHandler 接口,完成代理类要做的功能1.调用目标方法 2.功能增强 public class MySellHandler implements InvocationHandler { private Object target = null; public MySellHandler(Object target){ this.target = target; } @Override public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { //执行目标方法 Object res = method.invoke(target, args); //功能增强 if(res != null){ Float price = (Float)res; price = price + 25; res = price; } return res; } }
4、使用proxy类的静态方法,创建代理对象。并把返回值转为接口类型。
package com.bjpowernode; import com.bjpowernode.factory.UsbKingFactory; import com.bjpowernode.handler.MySellHandler; import com.bjpowernode.service.UsbSell; import java.lang.reflect.InvocationHandler; import java.lang.reflect.Method; import java.lang.reflect.Proxy; public class MainShop { public static void main(String[] args) { //创建代理对象,使用Proxy //1、创建目标对象 UsbSell factory = new UsbKingFactory(); //2、创建InvocationHandler对象 InvocationHandler handler = new MySellHandler(factory) ; //3、获取代理对象,代理对象即为proxy(注意:将该代理对象强转为原接口的对象) UsbSell proxy = (UsbSell) Proxy.newProxyInstance(factory.getClass().getClassLoader(), factory.getClass().getInterfaces(), handler); //4.通过代理对象执行方法 float price = proxy.sell(1); System.out.println("通过代理执行对象"+price); } }
Copyright © 2003-2013 www.wpsshop.cn 版权所有,并保留所有权利。