1

2 静态代理

2-1 一个发送短信接口

/**
 * 发送短信
 */
public interface SmsInterface {
    String send(String message);
}

2-2 发送短信接口实现

public class SmsImpl implements SmsInterface {

    @Override
    public String send(String message) {
        System.out.println("send msg:"+message);
        return message;
    }
}

2-3 静态代理

/**
 * 发送短信接口的代理类
 * 1-实现相同的接口
 * 2-引用原来实现类
 */
public class SmsProxy implements SmsInterface {

    private SmsImpl sms;

    public SmsProxy(SmsImpl sms) {
        this.sms = sms;
    }

    @Override
    public String send(String message) {
        //调用方法之前，我们可以添加自己的操作
        System.out.println("before method send()");
        sms.send(message);
        //调用方法之后，我们同样可以添加自己的操作
        System.out.println("after method send()");
        return message;
    }
}

3 动态代理

3-1 卖电脑接口

/**
 * 电脑接口
 */
public interface SaleComputer {

    /**
     * 这个方法用了代理增强
     * @param money
     * @return
     */
    public String sale(double money);

    /**
     * 这个方法没增强
     */
    public void show();
}

3-2 接口实现

public class Lenovo implements SaleComputer {


    @Override
    public String sale(double money) {

        System.out.println("花了" + money + "元买了一台联想电脑...");
        return "联想电脑";
    }


    @Override
    public void show() {
        System.out.println("展示电脑....");
    }
}

3-3 代理类

/**
 * 动态代理卖电脑
 */
public class ProxyComputer {


    //1.创建真实对象
    private static Lenovo lenovo = new Lenovo();


    public static void main(String[] args) {



        //2.动态代理增强lenovo对象
        /*
            三个参数：
                1. 类加载器：真实对象.getClass().getClassLoader()
                2. 接口数组：真实对象.getClass().getInterfaces()
                3. 处理器：after InvocationHandler()
         */
        SaleComputer proxy_lenovo = (SaleComputer) Proxy
            .newProxyInstance(lenovo.getClass().getClassLoader(), lenovo.getClass().getInterfaces(), new InvocationHandler() {

            /*
                代理逻辑编写的方法：代理对象调用的所有方法都会触发该方法执行
                    参数：
                        1. proxy:代理对象
                        2. method：代理对象调用的方法，被封装为的对象
                        3. args:代理对象调用的方法时， 传递的实际参数
             */
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

                //判断是否是sale方法
                if(method.getName().equals("sale")){
                    //1.增强参数
                    double money = (double) args[0];
                    money = money * 0.85;
                    System.out.println("专车接你....在方法的执行前增强");
                    //使用真实对象调用该方法
                    String obj = (String) method.invoke(lenovo, money);
                    System.out.println("免费送货...在方法的执行后增强");
                    //2.增强返回值
                    return obj+"_送你一个鼠标垫【对方法的返回值增强】";
                }else{
                    Object obj = method.invoke(lenovo, args);
                    return obj;
                }

            }
        });

        //3.调用方法
        String computer = proxy_lenovo.sale(8000);
        System.out.println(computer);
        proxy_lenovo.show();
    }
}

标签：lenovo,String,money,代理,模式,println,public
来源： https://www.cnblogs.com/hellosiyu/p/15678186.html