java 代理模式简述

一、什么是代理模，代理模式有哪些特征？

       1.1 、什么是代理：代理在我们身边很常见，比如帮我们 买火车票的黄牛，租房的中介，AOP 等等都是代理，我们不想做或者没时间做而不得不做的事去委托别人去做，它就是代理。

      1.2、 代理模式有哪些特征呢？

                 特征一：它有一个被代理对象（代理的目标target）、一个代理对象

                 特征二：虽然他是让别人替自己干事，但是最终的决定权在自己上手，这个理解起来有点抽象

                 特征三：代理对象持有被代理对象的引用

 

      1.3、代理模式的类别

               代理模式有两种类型：

                                            1、静态代理 （我们采用Hard Code 的方式）

                                            2、动态代理 （在运行时动态生成字节码文件去替我们干事，在Spring 中有两种：1、jdk 2、CGLib）

    二、静态代理的实现（以我们在项目中的向数据库中添加记录添加日志为例）

         

 

//用户实体类

public class UserEntity implements Serializable {
    private int id;
    private String name;
    private int age;


}

//定义用户接口
public interface UserService {

    //向数据库添加一条记录
    public void add(UserEntity userEntity);


}
//
/*
接口实现类：正常情况下，我们在这个类添加日志，

但现在我们并没有改这个类的东西，在某种程度上是符合设计原则的
*/
public class UserImpl implements  UserService {

    private UserDao userDao=new UserDao();

    public void add(UserEntity userEntity) {
     
        userDao.add(userEntity);
     
    }
}
//接下来我们的日志代理出现了

/**
 * 观察代理类的特征：
 *             1、拥有被代理对象UserImpl的引用UserService
 *             2、 this.userService.add(userEntity); 这里做日志的最终决定权在被代理对象决定
 * */
public class UserProxy implements  UserService {

    private UserService userService;

    public UserProxy(UserService userService) {
        this.userService = userService;
    }

    public void add(UserEntity userEntity) {
        System.out.println("增加前置日志");
        this.userService.add(userEntity);
        System.out.println("增加后置日志");
    }
}
//我们的测试类
public class Test {
    public static void main(String[] args) {
        UserProxy userProxy=new UserProxy(new UserImpl());
        userProxy.add(new UserEntity());
    }
}
//输出结果如下

增加前置日志
向数据库增加了一条记录
增加后置日志

 

                       

 

     三、动态地理（jdk）的实现

           

  

package com.whs.proxy.log;

import com.whs.proxy.staticed.Person;

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

public class DyProxy implements InvocationHandler {
    private UserService target;

    public Object getInstance(UserService target) throws Exception{
        this.target = target;

        Class<?> clazz = target.getClass();

        //下半截，老师深入底层来给大家讲解字节码是如何重组的
        //用来生成一个新的对象（字节码重组来实现）
        return Proxy.newProxyInstance
                (
                        clazz.getClassLoader(),
                        clazz.getInterfaces(),
                    this
                );
    }


    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        Class<?> clazz=target.getClass();
        System.out.println("增加前置日志");

        method.invoke(this.target,args);
        System.out.println("增加后置日志");
        return null;
    }
}
//测试文件
 public static void main(String[] args) {

 try
       {
           UserService obj = (UserService)new DyProxy().getInstance(new UserImpl());
           //System.out.println(obj.getClass());
           obj.add(new UserEntity());
       }catch(Exception  e)
       {
           e.printStackTrace();
       }
}