您的位置:首页 > 编程语言 > Java开发

java 反射提取类信息, 动态代理 和过滤某些方法演示

2014-08-07 15:15 477 查看
java 反射提取类信息, 动态代理 和过滤某些方法演示

package org.rui.classts.reflects;

import java.lang.reflect.Constructor;
import java.lang.reflect.Method;
import java.util.regex.Pattern;

/**
* 提取 类的  方法 构造器
* @author lenovo
*
*/
//{args:ShowMethods}
//查看一个类的全部方法和构造器
public class ShowMethods {
private static String usage="usage:showMethod qualified.class.mane";

private static Pattern p=Pattern.compile("\\w+\\.");

public static void main(String[] args) throws ClassNotFoundException {

//System.out.println(args[0]+"  :  "+args[1]);
args=new String[1];
args[0]="org.rui.classts.reflects.ShowMethods";
//args[1]="java.awt.Color";

if(args.length<1)
{
System.out.println(usage);
System.exit(0);
}
int lines=0;
Class<?> c=Class.forName(args[0]);
Method[] m=c.getMethods();
Constructor[] constructor=c.getConstructors();
if(args.length==1)
{
for(Method mt:m)
{
//System.out.println("tostring:"+mt.toString());
//去掉带 点和前面的字符 如  xx.ss.
System.out.println("m1:"+
p.matcher(mt.toString()).replaceAll("")
);
}
//----------------------------------------
for(Constructor con:constructor)
System.out.println("c1:"+
p.matcher(con.toString()).replaceAll("")
);
lines=m.length+constructor.length;
}
else
{
for(Method mt:m)
{
if(mt.toString().indexOf(args[1])!=-1)
{
System.out.println("m2:"+
p.matcher(mt.toString()).replaceAll("")
);
lines++;
}

}
//----------------------------------------
for(Constructor con:constructor)
{
if(con.toString().indexOf(args[1])!=-1)
{
System.out.println("c2:"+
p.matcher(con.toString()).replaceAll("")
);
lines++;
}

}
}

}

}


package org.rui.classts.reflects;

/**
* 简单动态代理 实现
* @author lenovo
*
*/
interface Interface
{
void doSomething();
void somethingElse(String arg);
}
//class------------------
class RealObject implements Interface{
public void doSomething() {
System.out.println("RealObject doSomething");
}

public void somethingElse(String arg) {
System.out.println("RealObject somethingElse:"+arg);
}
}
//class-SimpleProxy-----------------
class SimpleProxy implements Interface{
private Interface proxied;

public SimpleProxy(Interface proxied){this.proxied=proxied;}

//method
public void doSomething() {
System.out.println("SimpleProxy doSomething");
proxied.doSomething();
}

public void somethingElse(String arg) {
System.out.println("SimpleProxy somethingElse:"+arg);
proxied.somethingElse(arg);
}
}

public class SimpleProxyDemo {

public static void consumer(Interface inta)
{
inta.doSomething();
inta.somethingElse("bonobo");
}

//main----------
public static void main(String[] args)
{
//Interface o=new RealObject();
//真实对象去实现
consumer(new RealObject());
//代理去实现
consumer(new SimpleProxy(new RealObject()));

}

}


package org.rui.classts.reflects;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

//DynamicProxyHandler
class DynamicProxyHandler  implements InvocationHandler{

private Object proxied;

public DynamicProxyHandler(Object proxied)
{
this.proxied=proxied;
}

@Override
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable {
System.out.println("proxy:=="+proxy.getClass()
+"\nmethod:=="+method
+" \nargs:"+args);

if(args!=null)
for(Object o:args)
System.out.println("arg:"+o);
//把 实际对象给  proxied
return method.invoke(proxied, args);

}
}

class SimpleDynamicProxy{
public static void consumer(Interface iface)
{
iface.doSomething();
iface.somethingElse("bonobo==");
}

public static void main(String[] args) {
RealObject robj=new RealObject();
consumer(robj);

//代理
//返回一个指定接口的代理类实例,该接口能够将方法调用指派到指定的调用处理程序。
Interface proxy=(Interface) Proxy.newProxyInstance(
Interface.class.getClassLoader(), // 定义代理类的类载入器
new Class[]{Interface.class},// 代理类要实现的接口列表
new DynamicProxyHandler(robj)//指派方法调用的调用处理程序
);
consumer(proxy);

}
}


package org.rui.classts.reflects;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
/**
* 动态代理过滤某些方法 的演示
* @author lenovo
*
*/

class MethodSelector implements InvocationHandler
{
private Object obj;
public MethodSelector(Object o){this.obj=o;}
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable
{
//System.out.println("proxy:"+proxy.getClass().getSimpleName());
//能够拦截特殊处理
if(method.getName().equals("interesting"))
{
System.out.println("proxy detected the interesting method");
}
return method.invoke(obj, args);
}
}

// interface
interface SomeMethod
{
void boring1();
void interesting(String arg);
void boring2();
void boring3();
}
//------------------------------
class Implementation implements SomeMethod
{
public void boring1()
{
System.out.println("boring1");
}
public void interesting(String arg)
{
System.out.println("interesting:"+arg);
}
public void boring2()
{
System.out.println("boring2");
}

public void boring3()
{
System.out.println("boring3");

}

}

//
public class SelectingMethods {
public static void main(String[] args)
{
//代理測试
SomeMethod proxy =(SomeMethod)Proxy.newProxyInstance(
SomeMethod.class.getClassLoader(), // 定义代理类的类载入器
new Class[]{SomeMethod.class},// 代理类要实现的接口列表
new MethodSelector(new Implementation())//指派方法调用的调用处理程序
);

proxy.boring1();
proxy.boring2();
proxy.interesting("bonobo");
proxy.boring3();

}

}


对照測试

package org.rui.classts;

import org.rui.classts.chilnd.*;

public class PetCount4 {

public static void main(String[] args) {
Pet p=new Dog();
Class c=Pet.class;
Class c1=Dog.class;
Class c2=Cat.class;
//对象对照 类
if(p instanceof Dog){
System.out.println("true");
}else	System.out.println("fales");

//class 对照 对象
if(c.isInstance(p)){
System.out.println("true");
}else	System.out.println("fales");
// class对照class
if(c.isAssignableFrom(c1)){
System.out.println("true");
}else	System.out.println("fales");

if(c2.isAssignableFrom(c1)){
System.out.println("true");
}else	System.out.println("fales");

System.out.println("c==c1:"+(c==c1));
System.out.println("c.equals(c1:"+(c.equals(c1)));

System.out.println("c==Pet.class:"+(c==Pet.class));
System.out.println("c.equals(Pet.class:"+(c.equals(Pet.class)));

}

}
内容来自用户分享和网络整理,不保证内容的准确性,如有侵权内容,可联系管理员处理 点击这里给我发消息
标签: