String--狂神--静态代理和动态代理

静态代理

写死的Userservice增强

package com.liu.demo02;

public class UserServiceProxy implements UserService {
     

    private UserService userService;

    public UserService getUserService() {
     
        return userService;
    }

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


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

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

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

    public void qurey() {
     
        log("qurey");
       userService.qurey();
    }

    public void log(String msg){
     
        System.out.println("【日志】 使用了"+msg+"方法");
    }

}

Client

package com.liu.demo02;

public class Client {
     
    public static void main(String[] args) {
     
        UserServiceImpl userService = new UserServiceImpl();

        UserServiceProxy userServiceProxy = new UserServiceProxy();
        userServiceProxy.setUserService(userService);
        userServiceProxy.update();
    }
}

动态代理

InvocationHandler：调用处理程序；

动态代理模板抽取

package com.liu.demo04;
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);
    }


    //处理代理实例，并返回结果
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
     
        //动态代理的本质，就是使用反射机制实现！
        log(method.getName());
        Object result = method.invoke(target, args);
        return result;
    }

    //代理中的要增强的方法！
    public void log(String msg){
     
        System.out.println("【日志】执行了"+msg+"方法");
    }


}

Client

package com.liu.demo04;

import com.liu.demo02.UserService;
import com.liu.demo02.UserServiceImpl;

public class Client {
     

    public static void main(String[] args) {
     
        //真实角色
        UserServiceImpl userService = new UserServiceImpl();

        //代理角色
        ProxyInvocationHandler pih = new ProxyInvocationHandler();
        pih.setTarget(userService); // 设置要代理的对象

        //动态生成代理类
        UserService proxy = (UserService) pih.getProxy();

        proxy.add();
    }

}

动态代理的好处：

• 可以使真实角色的操作更加纯粹！不用关注一些公共业务；
• 公共也就交给代理角色！实现业务分工；
• 公共业务发生拓展时候，方便集中管理；
• 一个动态代理类的是一个接口，一般对应一个业务；
• 一个动态代理类可以代理多个类，只要是实现了同一个接口即可；