反射
public class Servant {
private int a;
private String str;
public Servant() {
}
public Servant(String string,int _a) {
}
public int getA() {
return a;
}
public void setA(int a) {
this.a = a;
}
public String getStr() {
return str;
}
}
public class Main {
public static void main(String[] args) {
System.out.println("-----------------反射基本使用-------------------");
//1获取类对象 3种方式
Servant servant = new Servant();
Class<?> clazz = servant.getClass(); //方式1
Class<?> clazz1 = Servant.class; //方式2
try {
Class<?> clazz2 = Class.forName("Reflection.Servant"); //方式3
}catch (ClassNotFoundException e) {
e.printStackTrace();
}
//创建对象
try {
Class<?> clazz3 = Servant.class;
Servant servant1 = (Servant)clazz3.getDeclaredConstructor().newInstance();
servant1.setA(10);
System.out.println(servant1.getA());
} catch (InstantiationException e) {
e.printStackTrace();
} catch (InvocationTargetException e) {
e.printStackTrace();
} catch (NoSuchMethodException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
}
/*************************************************************************************/
System.out.println("获取构所有构造函数---------------");
Class<?> clazz4 = Servant.class;
Constructor[] constructors = clazz4.getDeclaredConstructors();
for (Constructor constructor:constructors) {
System.out.println(constructor);
}
try {
System.out.println("获取指定构造函数---------------");
Class<?> clazz5 = Servant.class;
Constructor constructor = clazz5.getDeclaredConstructor(String.class,int.class);
System.out.println(constructor);
} catch (NoSuchMethodException e) {
e.printStackTrace();
}
/*************************************************************************************/
System.out.println("获取类中所有的方法---------------");
Class<?> clazz6 = Servant.class;
Method[] methods = clazz6.getMethods();
for (Method method:methods) {
System.out.println(method);
}
System.out.println("获取指定方法----------------");
try {
Method method = clazz6.getDeclaredMethod("setA",int.class);
method.setAccessible(true);
System.out.println(method);
method.setAccessible(false);
} catch (NoSuchMethodException e) {
e.printStackTrace();
}
/*************************************************************************************/
System.out.println("获取类中所有成员变量------------------");
Class<?> clazz7 = Servant.class;
Field[] fields = clazz7.getDeclaredFields();
for (Field field:fields) {
System.out.println(field);
}
System.out.println("获取类中指定成员变量--------------");
Class<?> clazz8 = Servant.class;
try {
Field field = clazz8.getDeclaredField("str");
System.out.println(field);
Servant servant1 = new Servant();
field.setAccessible(true);
field.set(servant1,"12345678");
System.out.println(field.getName()+" "+servant1.getStr());
} catch (NoSuchFieldException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
}
}
}
代理模式
定义:代理模式就是给目标对象提供一个代理对象,并由代理对象控制目标对象的引用。通俗来说:就是我们生活中常见的中介。
目的:
(1)通过引入代理对象的方式来间接访问目标对象,防止直接访问目标对象给系统带来的不必要复杂性;
(2)通过代理对象对原有的的业务增强。
代理模式分为静态代理和动态代理
静态代理
抽象角色:
定义代理角色和真实角色的公共对外方法
真实角色:
实现抽象角色,定义真实角色所要实现的业务逻辑,供代理角色调用。
代理角色:
实现抽象角色,是真实的代理,通过真实角色的业务逻辑方法来实现抽象方法,并可以附加自己的操作。
静态代理:程序在编译期间就确定了代理和被代理的关系
接口: Start
Start ->实现 RealStart
Start ->实现 ProxyStart
ProxyStart 是代理类包含RealStart
public interface Start {
public void bookTicket();
public void Config();
public void CollectMoney();
public void sing();
}
public class RealStart implements Start{
@Override
public void bookTicket() {
System.out.println("RealStart bookTicket");
}
@Override
public void Config() {
System.out.println("RealStart Config");
}
@Override
public void CollectMoney() {
System.out.println("RealStart CollectMoney");
}
@Override
public void sing() {
System.out.println("RealStart sing");
}
}
public class ProxyStart implements Start {
private Start start;
public ProxyStart(Start _start) {
start=_start;
}
@Override
public void bookTicket() {
System.out.println("ProxyStart bookTicket");
}
@Override
public void Config() {
System.out.println("ProxyStart Config");
}
@Override
public void CollectMoney() {
System.out.println("ProxyStart CollectMoney");
}
@Override
public void sing() {
start.sing();
}
}
public static void main(String[] args) {
System.out.println("-------------简单代理--------------");
Start realStart = new RealStart();
Start proxyStart = new ProxyStart(realStart);
proxyStart.CollectMoney();
proxyStart.bookTicket();
proxyStart.sing();
}
动态代理
动态代理相比静态代理的优点:
只能通过接口来创建代理类,不能通过类来创建代理类
动态代理利用反射机制效率比静态代理低,在程序运行时才确定代理和被代理之间的关系
实现InvocationHandler(处理器接口) 方式实现:
步骤:
1.真实对象接口
2.创建真实对象 实现接口
3.创建对象 实现 InvocationHandler接口
4.通过 Proxy.newProxyInstance(ClassLoader.getSystemClassLoader(),new Class[]{Shop.class},invocationHandler); 实现代理
参数:
ClassLoader 类加载去
Class<?>[] interfaces 代理类的接口
InvocationHandler 实现InvocationHandler的类
public interface Shop {
void buy();
}
public class Real implements Shop {
@Override
public void buy() {
System.out.println("--买东西--");
}
}
public class Invocation implements InvocationHandler {
public Shop shop;
public Invocation(Shop _shop) {
shop =_shop;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println("开始海外代购");
Object object = method.invoke(shop,args);
System.out.println("海外代购完成");
return object;
}
}
public class Main {
public static void main(String[] args) {
Shop shop = new Real();
InvocationHandler invocationHandler = new Invocation(shop);
Shop proxy = (Shop) Proxy.newProxyInstance(ClassLoader.getSystemClassLoader(),new Class[]{Shop.class},invocationHandler);
proxy.buy();
}
}
例如2:
public class MarkCompany implements InvocationHandler {
private Object factory;//真实对象
public void setFactory(Object factory) {
this.factory = factory;
}
public Object getFactory() {
return factory;
}
public Object getProxyInstance() {
//参数1 真实对象的类加载器 参数2 真实对象的接口 参数3 被代理的InvocationHandler
return Proxy.newProxyInstance(factory.getClass().getClassLoader(),factory.getClass().getInterfaces(),this);
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
Object object = null;
Before();
object = method.invoke(factory,args);
After();
return object;
}
public void Before() {
System.out.println("开始行动");
}
public void After() {
System.out.println("行动完成");
}
}
public interface Shop {
public void shopeat();
}
public class Real implements Shop {
@Override
public void shopeat() {
System.out.println("代购");
}
}
public class Main {
public static void main(String[] args) {
Shop shop = new Real(); //真实对象
MarkCompany markCompany = new MarkCompany();
markCompany.setFactory(shop);
//代理对象1
Shop shop1 = (Shop) markCompany.getProxyInstance();
shop1.shopeat();
//代理对象2
//代理对象3
}
}