javaSE ---- 动态代理

1.动态代理

/**
 * @Author xiaoqi
 * @Date
 * 动态代理
 * 必须声明一个接口，必须声明接口的实现类
 * 代理的其实是 你所定义的接口的实现类
 * 代理类和实现类没有任何关系，他们的联系就是实现了同一个接口
 */

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

/**
 * 定义一个接口，；里面定义了add，delete，insert方法
 */
interface CRUD{
    void add();
    void delete();
    void insert();
}

/**
 * 定义一个实现类，实现接口，这个类就是被代理的类
 *
 * 现在有这样一个需求，在每个方法之前都要进行检查，和检查完之后的声明
 * 如果是以前的方法
 *  System.out.println("这是检查的方法");
 *  System.out.println("这是增加的方法");
 *  System.out.println("这是检查完毕的方法");
 *    在每个方法里面都要加上如上操作，这样的话，我们的代码就会显得非常的臃肿
 *    除此之外，如果检查方法发生改变，那么我们就必须将我们实现的方法全部修改
 *    显然是非常麻烦的，所以，可以用我们的动态代理
 */
class CRUDImpl implements CRUD{

    @Override
    public void add () {
        System.out.println("这是增加的方法");

    }

    @Override
    public void delete () {
        System.out.println("这是删除的方法");
    }

    @Override
    public void insert () {
        System.out.println("这是插入的方法");
    }
}
// 使用动态代理的测试
public class DProxyTest {
    public static void main ( String[] args ) {
        final CRUDImpl crud = new CRUDImpl();
        //使用匿名内部类实现接口中的方法
        InvocationHandler handler = new InvocationHandler() {
            @Override
            public Object invoke ( Object proxy, Method method, Object[] args ) throws Throwable {
                /**
                 * 利用反射，执行被代理类的方法
                 * 第一个参数：所执行的方法所属的对象
                 * 第二个参数：执行方法的参数
                 * 返回值 就是执行方法之后的结果
                 */
                System.out.println("检查的方法");
                Object invoke = method.invoke(crud, args);
                System.out.println("检查完毕的方法");
                return invoke;
            }
        };
        /**
         * 这个方法就是生成我们的代理对象的类
         * 第一个参数：被代理类的类加载器
         * 第二个参数：被代理类实现的接口
         * 第三个参数：InvocationHandler 其实就是执行我们被代理类的方法
         */
//        这里转化的时候，使用接口
        CRUD o = (CRUD) Proxy.newProxyInstance(
                crud.getClass().getClassLoader(), crud.getClass().getInterfaces(), handler);
        o.add();
    }

}

2 .静态代理的简单介绍

package com.wcc.proxy;

/**
 * @Author xiaoqi
 * @Date
 * 静态代理的举例
 * 其本质还是应用了面向对象的多态
 */
//声明一个接口
interface Factory{
    void makeCloth();
}
//代理类
class ProxyFactory implements Factory{

    private Factory factory;
    public ProxyFactory(Factory factory){
        this.factory = factory;
    }
    @Override
    public void makeCloth () {
        System.out.println("开始生产衣服");
        factory.makeCloth();
        System.out.println("生产完毕，请厂长指示");
    }
}
// 新建一个类实现Factory接口
class JFXFactory implements Factory{

    @Override
    public void makeCloth () {
        System.out.println("生产了一批花衣服");
    }
}
public class Proxytest {
    public static void main ( String[] args ) {
        JFXFactory factory = new JFXFactory();
        ProxyFactory proxyFactory = new ProxyFactory(factory);
        proxyFactory.makeCloth();
        /** 打印结果
         * 开始生产衣服
         *生产了一批花衣服
         *生产完毕，请厂长指示
         **/
    }
}