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

淡淡的烟草味﹌ 2022-09-16 03:42 95阅读 0赞

## 静态代理 ##

写死的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();
        }
    
    }

#### 动态代理的好处： ####

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