静态代理和JDK动态代理

谁践踏了优雅 2022-05-09 06:50 240阅读 0赞

## 静态代理 ##

**1 静态代理角色分析**  
静态代理由代理对象代理所有真实对象的功能，由自己编写代理类，每个代理功能需要单独编写

1.  抽象角色——一般为接口或抽象类（某些抽象功能）
2.  真实角色——被代理的角色
3.  代理角色——代理（依赖）真实角色（一般会有附属操作）

**2 使用静态代理的好处**

1.  使得真实角色处理处理的业务更加纯粹，不在关注其他公共的事务
2.  公共业务由代理来完成——实现业务的分工
3.  公共业务发生扩展时变得更加集中和方便

**3 使用静态代理的缺点**

1.  多了代理类，增加了工作量，开发效率低

**4 代码**  
*抽象角色*

public interface UserService {
    	public void add();
    	public void update();
    	public void delete();
    	public void query();
    }

*真实角色*

public class UserServiceImpl implements UserService {
    
    	@Override
    	public void add() {
    		System.out.println("增加用户");
    	}
    
    	@Override
    	public void update() {
    		System.out.println("修改用户");
    	}
    
    	@Override
    	public void delete() {
    		System.out.println("删除用户");
    	}
    
    	@Override
    	public void query() {
    		System.out.println("查询用户");
    	}
    }

*代理角色*

public class UserServiceProxy implements UserService {
    
    	private UserService userService;
    	@Override
    	public void add() {
    		log("add");
    		userService.add();
    	}
    
    	@Override
    	public void update() {
    		log("update");
    		userService.update();
    	}
    
    	@Override
    	public void delete() {
    		log("delete");
    		userService.delete();
    	}
    
    	@Override
    	public void query() {
    		log("query");
    		userService.query();
    	}
    	
    	public void log(String methodName) {
    		System.out.println("执行了" + methodName + "()方法");
    	}
    
    	public UserServiceProxy(UserService userService) {
    		super();
    		this.userService = userService;
    	}
    }

*测试类*

public class Test {
    	public static void main(String[] args) {
    		UserServiceImpl us = new UserServiceImpl();
    		UserServiceProxy proxy = new UserServiceProxy(us);
    		proxy.add();
    		proxy.delete();
    		proxy.delete();
    		proxy.update();
    		proxy.query();
    		
    	}
    }

*结果*

执行了add()方法
    增加用户
    执行了delete()方法
    删除用户
    执行了delete()方法
    删除用户
    执行了update()方法
    修改用户
    执行了query()方法
    查询用户

代理角色在真实角色的基础上增加了日志功能

## JDK动态代理 ##

为了解决静态代理频繁编写代理功能的缺点  
**1 动态代理角色分析**（同静态代理）

1.  抽象角色——一般为接口或抽象类
2.  真实角色——被代理的角色
3.  代理角色——代理（依赖）真实角色（一般会有附属操作）

**2 动态代理特点**  
代理角色动态生成  
基于接口的动态代理——jdk动态代理，不需要导入额外jar包，缺点：真实对象必须实现接口，利用反射机制，效率不高  
基于类的动态代理——cglib动态代理

**3 代码**  
*抽象角色*（同静态）  
*真实角色*（同静态）  
*代理角色*

public class ProxyInvocationHandler implements InvocationHandler {
    	private Object target;
    	
    	public void setTarget(Object target) {
    		this.target = target;
    	}
    	/**
    	 * 生成代理类
    	 */
    	public Object getProxy() {
    	   //java.lang.reflect.Proxy
    		return Proxy.newProxyInstance(this.getClass().getClassLoader(), target.getClass().getInterfaces(), this);
    	}
    	/**
    	 * proxy是代理类  
    	 * Method是代理类的调用处理程序的方法对象
    	 */
    	@Override
    	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 methodName) {
    		System.out.println("执行了" + methodName + "()方法");
    	}
    }

*测试类*

public class Client {
    	public static void main(String[] args) {
    		UserService us = new UserServiceImpl();
    		ProxyInvocationHandler pih = new ProxyInvocationHandler();
    		pih.setTarget(us);
    		UserService proxy = (UserService) pih.getProxy();
    		proxy.add();
    	}
    }

*结果*

执行了add()方法
    增加用户

当然也可以将生成代理类放在测试程序中，而功能要放在处理程序中

public class ProxyInvocationHandler2 implements InvocationHandler {
    	private UserService us = new UserServiceImpl();;	
    	
    	public void setUs(UserService us) {
    		this.us = us;
    	}
    
    	/**
    	 * proxy是代理类  
    	 * Method是代理类的调用处理程序的方法对象
    	 */
    	@Override
    	public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
    		log(method.getName());
    		Object result = method.invoke(us, args);		
    		return result;
    	}
    	
    	public void log(String methodName) {
    		System.out.println("执行了" + methodName + "()方法");
    	}
    }

测试类

public class Client2 {
    	public static void main(String[] args) {		
    		ProxyInvocationHandler2 pih = new ProxyInvocationHandler2();	
    		//第一个参数：反射时使用的类加载器
    		//第二个参数：Proxy需要实现什么接口
    		//第三个参数：通过接口对象调用方法是，需要调用哪个类的invoke方法	
    		UserService proxy = (UserService) Proxy.newProxyInstance(Client.class.getClassLoader(),new Class[] { UserService.class}, pih);
    		proxy.add();
    		proxy.delete();
    		proxy.update();;
    	}
    }

输出

执行了add()方法
    增加用户
    执行了delete()方法
    删除用户
    执行了update()方法
    修改用户