反射

了解反射用法：
反射一
反射二
练习

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
    }
}