我要干成人,海波依尔,福特fab1
一、java中的反射
1.通过反射加载类的属性和方法实例代码:
我要评论
/**
* java.lang.class 是反射的源头
* 我们创建了一个类，通过编译（javac.exe）生成对应的class文件，之后我们通过java.exe加载(jvm的类加载器加载)此class文件
* 此class文件加载到内存后，就是一个运行时类，存在缓存区，这个运行时类本事就是一个class的实例
* 每一个运行时类只加载一次，
*/
class<studentexam> clazz = studentexam.class;
studentexam studentexam = clazz.newinstance();
system.err.println(studentexam);
system.out.println(clazz);
// field field = clazz.getfield("id"); // 通过属性调用运行时类的指定属性：属性是public类型
field field = clazz.getdeclaredfield("id"); // 属性是非public 类型
field[] fields = clazz.getdeclaredfields(); // 获取运行时类本身(父类不行)所有声明的属性，父类使用clazz.getfields();
for (field field2 : fields) {
int i = field2.getmodifiers();
string type = modifier.tostring(i);// 获取字段属性的数据类型
system.out.println(type);
}
field.setaccessible(true);
field.set(studentexam, 11);
system.err.println(studentexam.getid());
// 通过反射调用运行时类的指定方法
method method = clazz.getmethod("setid", integer.class);
method.invoke(studentexam, 123); // 调用运行时类的指定方法
method[] methods = clazz.getmethods(); // 获取所有运行时类及其父类中所有声明为public的方法
method[] methods2 = clazz.getdeclaredmethods();// 获取运行时类本身类中声明的方法
for (method method2 : methods) {
system.out.println(method2.getname());
}
// * 通过对象的getclass()方法获取对象的运行时类，
exam exam = new exam();
class clazzexam = exam.getclass();
2.类加载器classloader
/**
* description:类加载器，加载xx.properties文件，并读取数据
* @param
* @author xiazhongwei
* @data 2016年9月29日:下午5:32:56
* @return
*/
public void classloader() throws ioexception {
//方法一、从当前工程下加载
classloader loader = this.getclass().getclassloader();
// 路径是包下写：com\\able\\onlineexam\\resources\\config.properties
inputstream instream = loader.getresourceasstream("config.properties");
// 方法二、从指定的路径下加载文件
// fileinputstream fileinputstream = new fileinputstream(new file("config.properties"));
properties properties = new properties();
properties.load(instream);
// properties.load(fileinputstream);
string prop = properties.getproperty("domain");
system.out.println(prop);
}
3.动态代理
静态代理:代理类和目标对象的类型都是在编译期间确定下来，不利于程序的扩展。同时每个代理类只能为一个接口服务，这样一来程序开发中必然产生过多的代理。
动态代理:客户通过代理类来调用其他对象的方法，并且是在程序运行时，根据需要动态创建目标类的代理对象。
代理设计模式的原理：
使用一个代理将对象包装起来，然后用该代理对象取代原始对象，任何对原始对象的调用都要通过代理，代理对象决定的那个是否以及何时将方法调用
package com.test.junit;
import java.lang.reflect.invocationhandler;
import java.lang.reflect.method;
import java.lang.reflect.proxy;
public class proxytest {
public static void main(string[] args) {
realsubject realsubject = new realsubject();
myinvocationhandler myinvocationhandler = new myinvocationhandler();
object object = myinvocationhandler.bind(realsubject);
subject subject = (subject) object;
subject.action();
}
}
// 动态代理的使用
interface subject{
void action();
}
// 被代理类
class realsubject implements subject{
@override
public void action() {
system.out.println("我是被代理类，记得执行我哦。。。。");
}
}
class myinvocationhandler implements invocationhandler{
object object;// 实现了接口的被代理类的对象的声明
/**
* description:①给被代理的对象实例化 ②返回一个代理类对象
* @param
* @author xiazhongwei
* @data 2016年9月29日:下午4:13:43
* @return
*/
public object bind(object object){
this.object = object;
return proxy.newproxyinstance(object.getclass().getclassloader(), object.getclass().getinterfaces(), this);
}
/**
* 当通过代理类的对象发起对被重写的方法的调用时，都会转化为对如下的invok方法的调用
*/
@override
public object invoke(object proxy, method method, object[] args)
throws throwable {
object returnobject = method.invoke(object, args);
return returnobject;
}
}
4.动态代理与aop
示例一、
package com.atguigu.spring.aop;
public interface arithmeticcalculator {
int add(int i, int j);
int sub(int i, int j);
int mul(int i, int j);
int div(int i, int j);
}
package com.atguigu.spring.aop;
import org.springframework.stereotype.component;
@component("arithmeticcalculator")
public class arithmeticcalculatorimpl implements arithmeticcalculator {
@override
public int add(int i, int j) {
int result = i + j;
return result;
}
@override
public int sub(int i, int j) {
int result = i - j;
return result;
}
@override
public int mul(int i, int j) {
int result = i * j;
return result;
}
@override
public int div(int i, int j) {
int result = i / j;
return result;
}
}
package com.atguigu.spring.aop;
public class arithmeticcalculatorloggingimpl implements arithmeticcalculator {
@override
public int add(int i, int j) {
system.out.println("the method add begins with [" + i + "," + j + "]");
int result = i + j;
system.out.println("the method add ends with " + result);
return result;
}
@override
public int sub(int i, int j) {
system.out.println("the method sub begins with [" + i + "," + j + "]");
int result = i - j;
system.out.println("the method sub ends with " + result);
return result;
}
@override
public int mul(int i, int j) {
system.out.println("the method mul begins with [" + i + "," + j + "]");
int result = i * j;
system.out.println("the method mul ends with " + result);
return result;
}
@override
public int div(int i, int j) {
system.out.println("the method div begins with [" + i + "," + j + "]");
int result = i / j;
system.out.println("the method div ends with " + result);
return result;
}
}
package com.atguigu.spring.aop;
import java.lang.reflect.invocationhandler;
import java.lang.reflect.method;
import java.lang.reflect.proxy;
import java.util.arrays;
public class arithmeticcalculatorloggingproxy {
//要代理的对象
private arithmeticcalculator target;
public arithmeticcalculatorloggingproxy(arithmeticcalculator target) {
super();
this.target = target;
}
//返回代理对象
public arithmeticcalculator getloggingproxy(){
arithmeticcalculator proxy = null;
// 代理对象有哪一个类加载器负责加载
classloader loader = target.getclass().getclassloader();
// 代理对象的类型，即其中有哪些方法
class [] interfaces = new class[]{arithmeticcalculator.class};
// 当调用代理对象的其中方法时，执行下面的代码
invocationhandler h = new invocationhandler() {
/**
* proxy: 代理对象。 一般不使用该对象
* method: 正在被调用的方法
* args: 调用方法传入的参数
*/
@override
public object invoke(object proxy, method method, object[] args)
throws throwable {
// 在方法内部不会直接调用proxy对象的某个方法，proxy.tostring()会造成死循环调用invoke方法
string methodname = method.getname();
//打印日志
system.out.println("[before] the method " + methodname + " begins with " + arrays.aslist(args));
//调用目标方法
object result = null;
try {
//前置通知
result = method.invoke(target, args);
//返回通知, 可以访问到方法的返回值
} catch (nullpointerexception e) {
e.printstacktrace();
//异常通知, 可以访问到方法出现的异常
}
//后置通知. 因为方法可以能会出异常, 所以访问不到方法的返回值
//打印日志
system.out.println("[after] the method ends with " + result);
return result;
}
};
/**
* loader: 代理对象使用的类加载器。
* interfaces: 指定代理对象的类型. 即代理代理对象中可以有哪些方法.
* h: 当具体调用代理对象的方法时, 应该如何进行响应, 实际上就是调用 invocationhandler 的 invoke 方法
*/
proxy = (arithmeticcalculator) proxy.newproxyinstance(loader, interfaces, h);
return proxy;
}
}
package com.atguigu.spring.aop;
import org.springframework.context.applicationcontext;
import org.springframework.context.support.classpathxmlapplicationcontext;
public class main {
public static void main(string[] args) {
// arithmeticcalculator arithmeticcalculator = new arithmeticcalculatorimpl();
arithmeticcalculator arithmeticcalculator = new arithmeticcalculatorloggingimpl();
arithmeticcalculator = new arithmeticcalculatorloggingproxy(arithmeticcalculator).getloggingproxy();
int result = arithmeticcalculator.add(11, 12);
system.out.println("result:" + result);
result = arithmeticcalculator.div(21, 3);
system.out.println("result:" + result);
}
}
示例二、
package com.test.junit;
import java.lang.reflect.invocationhandler;
import java.lang.reflect.method;
import java.lang.reflect.proxy;
public class proxytest {
public static void main(string[] args) {
realsubject realsubject = new realsubject();
myinvocationhandler myinvocationhandler = new myinvocationhandler();
object object = myinvocationhandler.bind(realsubject);
subject subject = (subject) object;
subject.action();
}
}
// 动态代理的使用
interface subject{
void action();
}
// 被代理类
class realsubject implements subject{
@override
public void action() {
system.out.println("我是被代理类，记得执行我哦。。。。");
}
}
class myinvocationhandler implements invocationhandler{
object object;// 实现了接口的被代理类的对象的声明
/**
* description:①给被代理的对象实例化 ②返回一个代理类对象
* @param
* @author xiazhongwei
* @data 2016年9月29日:下午4:13:43
* @return
*/
public object bind(object object){
this.object = object;
return proxy.newproxyinstance(object.getclass().getclassloader(), object.getclass().getinterfaces(), this);
}
/**
* 当通过代理类的对象发起对被重写的方法的调用时，都会转化为对如下的invok方法的调用
*/
@override
public object invoke(object proxy, method method, object[] args)
throws throwable {
object returnobject = method.invoke(object, args);
return returnobject;
}
}
感谢阅读此文，希望能帮助到大家，谢谢大家对本站的支持！
如对本文有疑问，请在下面进行留言讨论，广大热心网友会与你互动！！ 点击进行留言回复
apollo与springboot集成实现动态刷新配置的教程详解
网友评论