代理是 Java SE 1.3 新增加的⼀种特性，利⽤代理可以在运⾏时创建⼀个实现了⼀组给定接⼝的新类，通过代理类实现对⽬标类的调⽤。
代理是⼀种设计模式，它可以在⽬标对象的基础上，增加⼀些额外的功能，扩展⽬标对象的功能⽽不⽤修改已经存在的代码。
代理主要有3种方式：静态代理，动态代理（又称JDK代理），Cglib代理
无代理的情况
业务层Service直接调用UserDao对User对象进行保存
例子：我们现在有一个功能用户信息保存(直接打印出来模拟保存)，业务层Service发起用户信息保存的命令，UserDao对User对象进行保存
User对象User.java
public class User {
private String name;
private Integer age;
public User(String name, Integer age){
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Integer getAge() {
return age;
}
public void setAge(Integer age) {
this.age = age;
}
@Override
public String toString(){
StringBuilder str = new StringBuilder();
str.append("姓名：");
str.append(getName());
str.append(", 年龄：");
str.append(getAge());
return str.toString();
}
}
父类接口UserDao.java
public interface UserDao {
String save(User user);
void printData();
}
实现接口UserDao.java的，执行保存操作的UserDaoImpl.java
public class UserDaoImpl implements UserDao {
private static User[] userdata = new User[10];
private static int count = 0;
@Override
public String save(User user){
userdata[count] = user;
count = count + 1;
System.out.println(user.toString());
System.out.println("save success");
return "save success";
}
@Override
public void printData(){
System.out.println("目前保存的数据：");
for(int i = 0; i < count; i++){
System.out.println((userdata[i]).toString());
}
}
}
业务层调用，UserTestService.java
public class UserTestService {
public static void noProxyTest(){
User user1 = new User("依依", 19);
UserDao saveOpt = new UserDaoImpl();
saveOpt.save(user1);
User user2 = new User("双儿", -18);
saveOpt.save(user2);
User user3 = new User("", 17);
saveOpt.save(user3);
saveOpt.printData();
}
public static void main(String[] args){
// 无代理操作的用户数据保存
noProxyTest();
}
}
执行结果：
目前保存的数据：
姓名：依依, 年龄：19
姓名：双儿, 年龄：-18
姓名：, 年龄：17
可以看出，无代理模式下，暂时没有对姓名和年龄做限制，若不能在User.java和UserDaoImpl.java增加限制（因为是别人提供的，不好改他人的代码），则可以增加一层代理机制，对姓名和年龄做限制
代理主要做2件事情：
1、对User对象进行判断：承接来自业务层Service的调用，对业务层传来的User对象进行姓名和年龄的判断是否正常用户信息，非正常用户信息则给业务层返回失败信息
2、发起用户信息保存操作：若是正常用户信息，则调用UserDaoImpl对用户信息进行保存
静态代理
静态代理需要定义接口或父类，被代理对象与代理对象一起实现相同的接口或者继承相同的父类。
新增一个类实现UserDao接口（跟UserDaoImpl实现同一个接口）
UserDaoStaticProxy.java
public class UserDaoStaticProxy implements UserDao {
private UserDao saveOpt;
public UserDaoStaticProxy(UserDao saveOpt){
this.saveOpt = saveOpt;
}
@Override
public String save(User user){
// 对user数据进行判断，不符合规则返回失败信息
if(user.getName() == null || (user.getName().trim()).length() == 0)
return "姓名不合法";
if(user.getAge() <= 1 || user.getAge() > 170)
return "年龄不合理";
// 进行到这一步说明user数据是没有问题的了，则调用UserDaoImpl对数据进行保存
saveOpt.save(user);
return "save success";
}
@Override
public void printData() {
saveOpt.printData();
}
}
业务层UserTestService.java
public class UserTestService {
public static void staticProxyTest(){
User user4 = new User("丝丝", 19);
UserDao saveOpt = new UserDaoImpl();
UserDao saveProxy = new UserDaoStaticProxy(saveOpt);
saveProxy.save(user4);
User user5 = new User("王五", -18);
System.out.println(saveProxy.save(user5));
User user6 = new User("", 17);
System.out.println(saveProxy.save(user6));
saveProxy.printData();
}
public static void main(String[] args){
// 静态代理
staticProxyTest();
}
}
执行结果：
姓名：丝丝, 年龄：19
save success
年龄不合理
姓名不合法
目前保存的数据：
姓名：丝丝, 年龄：19
静态代理易于实现，但缺点也比较明显，就是当父类、接口有改动（比如增加一个方法）的时候，需要去改动代理对象UserDaoStaticProxy.java，对上层比较依赖，动态代理就解决了这个问题
动态代理（JDK代理）
JDK代理对象是通过反射机制在运行时创建代理类，需要实现InvocationHandler接口
动态代理类UserDaoDynamicProxy.java
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
public class UserDaoDynamicProxy implements InvocationHandler {
private Object object;
public UserDaoDynamicProxy(Object object){
this.object = object;
}
public int checkUserSave(String methodName, Object[] args){
// 只是UserDao对象的save操作，故对操作对象和方法进行判断，只有是UserDao对象和save方法才继续执行
if (!(this.object instanceof UserDao))
return 0;
if (!("save".equals(methodName)))
return 0;
// 对操作参数进行判断，即判断args是否为User对象
if (args == null || args.length < 1 || !(args[0] instanceof User))
return 0;
// 对User对象的姓名和年龄进行判断
User user = (User) args[0];
if (user.getName() == null || user.getName().trim() == "")
return -1;
if (user.getAge() == null || user.getAge() < 1)
return -2;
return 1;
}
@Override
public Object invoke(Object o, Method method, Object[] args) throws Throwable {
int flag = checkUserSave(method.getName(), args);
if (flag == -1)
return "姓名不合法";
else if(flag == -2)
return "年龄不合理";
// method.invoke(object, args)可以这样理解：object对象调用method方法，方法传入的参数是args
return method.invoke(this.object, args);
}
}
业务层调用，UserTestService.java
import java.lang.reflect.Proxy;
public class UserTestService {
public static void dynamicProxyTest(){
UserDao saveOpt = new UserDaoImpl();
// 获取当前⽬标对象使⽤的类加载器，即saveOpt使用的类加载器
ClassLoader classLoader = saveOpt.getClass().getClassLoader();
// 获取⽬标对象实现的接⼝类型，1 个或多个
// 目前saveOpt是UserDaoImpl的对象，UserDaoImpl只实现了一个接口UserDao，故只有UserDao一个接口
// 如果UserDaoImpl实现了多个接口，就会有多个接口，getInterfaces()是获得这个对象所实现的所有接口
Class[] interfaces = saveOpt.getClass().getInterfaces();
UserDaoDynamicProxy handler = new UserDaoDynamicProxy(saveOpt);
UserDao dynamicProxy = (UserDao) Proxy.newProxyInstance(classLoader, interfaces, handler);
User user7 = new User("", 13);
User user8 = new User("巴巴",-10);
User user9 = new User("啾啾", 23);
System.out.println(dynamicProxy.save(user7));
System.out.println(dynamicProxy.save(user8));
dynamicProxy.save(user9);
dynamicProxy.printData();
}
public static void main(String[] args){
// 动态代理
dynamicProxyTest();
}
}
执行结果：
姓名不合法
年龄不合理
姓名：啾啾, 年龄：23
save success
目前保存的数据：
姓名：啾啾, 年龄：23
根据上述示例代码，我们可以看出，代理对象不需要实现接⼝，但是⽬标对象必须是实现了接⼝，否则就不能使⽤动态代理。
动态代理是 JDK 提供的⼀个特性，被代理对象必须是实现了⼀组接⼝。创建代理类需要⽤到 JDK 提供的 Proxy.newProxyInstance ⽅法，它的语法为：
public static Object newProxyInstance(ClassLoader loader, Class[] interfaces, InvocationHandler h)
该⽅法是⼀个静态⽅法，接收三个参数：
ClassLoader loader 当前⽬标对象使⽤的类加载器
Class[] interfaces ⽬标对象实现的接⼝类型，1 个或多个
InvocationHandler h 事件处理，执⾏⽬标对象的⽅法时，⾃动触发事件处理器的 invoke ⽅法，并将⽅法和参数信息作为参数传⼊，InvocationHandler即我们实现的代理类
Cglib代理
参考文章：
JAVA动态代理