动态代理和静态代理-java描述

1.业务功能实现

package com.xxx.demo;

public class UserServiceImpl implements UserService {


    @Override
    public void add() {
        System.out.println("往数据库添加一条数据");

    }

    @Override
    public void delete() {
        System.out.println("删除数据库一条数据");
    }

    @Override
    public void update() {
        System.out.println("修改数据库一条数据");
    }

    @Override
    public void query(String m) {
        System.out.println("查询数据的数据");
    }
}

2.静态代理

2.1 静态代理实现

package com.xxx.demo;

/**
 * 静态代理：添加 一个log方法，不修改原来代码；开闭原则；AOP面向切面编程
 */
public class UserServiceProxy implements UserService {

    private UserService userService;

    public void setUserService(UserService userService) {
        this.userService = userService;
    }

    @Override
    public void add() {
        log("add");
        userService.add();
    }

    @Override
    public void delete() {
        log("delete");
        userService.delete();
    }

    @Override
    public void update() {
        log("update");
        userService.update();
    }

    @Override
    public void query(String msg) {
        log("query");
        userService.query(msg);

    }

    public void log(String log){
        System.out.println("打印Log："+log);
    }
}

2.2 静态代理测试

package com.xxx.demo;

import com.pfj.ProxyInvocationHandler;

public class Client {
    public static void main(String[] args) {
        UserService userService = new UserServiceImpl();
        // 代理类
        UserServiceProxy proxy = new UserServiceProxy();
        proxy.setUserService(userService);
        proxy.add();
        proxy.delete();
        proxy.query("查询");
        proxy.update();
    }
}

静态代理优点：

1.可以使真实角色更加纯粹，不用关心一些公共的业务
2.公共业务交给了代理角色，实现了业务分工
3.公共业务扩展的时候，方便集中管理
缺点：
一个角色就会产生一个代理角色；代码量翻倍，开发效率低

3.基于接口动态代理方式

3.1 代理模板

package com.xxx;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

public class ProxyInvocationHandler implements InvocationHandler {

    // 被代理的接口
    private Object target;

    public void setTarget(Object target) {
        this.target = target;
    }

    // 生成代理类
    public Object getProxy() {
        return Proxy.newProxyInstance(
                this.getClass().getClassLoader(),
                target.getClass().getInterfaces(),
                this);
    }

    // 处理代理实例,并返回结果
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) 
    throws Throwable {
    	// 为所有方法扩展功能，这里只简单打印一下
        System.out.println("方法名："+method.getName());
        // args : 方法入参集合
        if (args!=null) {
            System.out.println(args[0]);
        }
        // 动态代理的本质，就是使用反射机制实现的
        Object o = method.invoke(target, args);
        return o;
    }
}

3.2 测试

package com.xxx.demo;
import com.xxx.ProxyInvocationHandler;

public class Client {
    public static void main(String[] args) {
        UserService userService = new UserServiceImpl();
        ProxyInvocationHandler handler = new ProxyInvocationHandler();
        handler.setTarget(userService);// 设置代理对象
        // 动态生成代理类
        UserService proxy = (UserService) handler.getProxy();
        proxy.add();
        proxy.delete();
        proxy.query("查询");
        proxy.update();
    }
}

动态代理优点：

1.可以使真实角色更加纯粹，不用关心一些公共的业务
2.公共业务交给了代理角色，实现了业务分工
3.公共业务扩展的时候，方便集中管理
4.一个动态代理类代理一个接口，一般就是对应的一类业务(类的所有方法实现)
5.一个代理类可以代理多个类，只要是实现了同一个接口即可