Spring学习笔记--代理

静态代理

1.静态代理的角色分析(UML画图推荐使用StarUML软件)

　抽象角色---一般使用接口或者抽象类来实现。

　真实角色---被代理的角色。

代理角色---代理真实角色—代理真是角色后一般会做一些附属操作。

客户-------使用代理角色来进行一些操作.

2.代码的实现(房东-中介-客户)

　Rent.java--抽象角色

package cn.sxt.staticproxy;

public interface Rent {
	public void rent();
}

Host.java--真实角色

package cn.sxt.staticproxy;

public class Host implements Rent{
	@Override
	public void rent(){
		System.out.println("房屋出租");
	}
}

Proxy.java--代理角色

package cn.sxt.staticproxy;

public class Proxy implements Rent{
	private Host host;
	public Proxy(){

	}
	public Proxy(Host host) {
		super();
		this.host = host;
	}
	public void setHost(Host host) {
		this.host = host;
	}
	//租房
	public void rent(){
		seeHouse();
		host.rent();
		fare();
	}
	//看房
	private void seeHouse(){
		System.out.println("带房客看房");
	}
	//收中介费
	private void fare(){
		System.out.println("收取中介费");
	}
}

Client.java--客户

package cn.sxt.staticproxy;

public class Client {
	public static void main(String[] args) {

		Host host=new Host();
		Proxy proxy=new Proxy(host);
		proxy.rent();
	}
}

3.使用静态代理的好处：

使得真实角色处理的业务更加的纯粹，不再去关注一些公共的事情;

　     公共的业务由代理来完成---实现了业务的分工;

　     公共业务发生扩展时，变得更加集中和方便;

举例说明：

UserService.java:

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

UserServiceImpl.java:关注纯粹的业务逻辑

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 search() {

		System.out.println("查询用户");
	}
}

UserServiceProxy.java：处理一些公共的事务，比如日志

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 search() {
		log("search");
		userService.delete();
	}

	public void log(String methodName) {
		System.out.println("执行" + methodName + "执行");
	}

}

静态代理的缺点：

类变的多了---多了代理类，工作量变大了，开发效率降低了

于是乎----动态代理出现了：有静态代理的好处，抛弃静态代理的缺点

动态代理

1.动态代理和静态代理的角色是一样的。

2.动态代理的代理类是动态生成的。

3.动态代理分为两类

a)基于接口的动态代理---jdk动态代理

b)基于类的动态代理---cglib

现在用javasist来生成动态代理

4.jdk的动态代理---Proxy类和InvocationHandler接口

InvocationHandler 是代理实例的调用处理程序 实现的接口。

每个代理实例都具有一个关联的调用处理程序。对代理实例调用方法时，将对方法调用进行编码并将其指派到它的调用处理程序的 invoke 方法。

invoke方法：

Object

invoke(Object proxy, Method method, Object[] args)           在代理实例上处理方法调用并返回结果。

在代理实例上处理方法调用并返回结果。在与方法关联的代理实例上调用方法时，将在调用处理程序上调用此方法。

参数：

proxy - 在其上调用方法的代理实例

method - 对应于在代理实例上调用的接口方法的 Method 实例。Method 对象的声明类将是在其中声明方法的接口，该接口可以是代理类赖以继承方法的代理接口的超接口。

args - 包含传入代理实例上方法调用的参数值的对象数组，如果接口方法不使用参数，则为 null。基本类型的参数被包装在适当基本包装器类（如 java.lang.Integer 或 java.lang.Boolean）的实例中。

返回：

从代理实例的方法调用返回的值。如果接口方法的声明返回类型是基本类型，则此方法返回的值一定是相应基本包装对象类的实例；否则，它一定是可分配到声明返回类型的类型。如果此方法返回的值为 null 并且接口方法的返回类型是基本类型，则代理实例上的方法调用将抛出 NullPointerException。否则，如果此方法返回的值与上述接口方法的声明返回类型不兼容，则代理实例上的方法调用将抛出 ClassCastException。

Proxy 提供用于创建动态代理类和实例的静态方法，它还是由这些方法创建的所有动态代理类的超类。

static Object

newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h)           返回一个指定接口的代理类实例，该接口可以将方法调用指派到指定的调用处理程序。

返回一个指定接口的代理类实例，该接口可以将方法调用指派到指定的调用处理程序。此方法相当于：

     Proxy.getProxyClass(loader, interfaces).
         getConstructor(new Class[] { InvocationHandler.class }).
         newInstance(new Object[] { handler }); 

Proxy.newProxyInstance 抛出 IllegalArgumentException，原因与 Proxy.getProxyClass 相同。

参数：

loader - 定义代理类的类加载器

interfaces - 代理类要实现的接口列表

h - 指派方法调用的调用处理程序

实现：

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);
	}

	/**
	 * proxy--是代理类
	 * method--代理类的实例(proxy)调用的处理程序(add)的方法对象
	 * 比如调用proxy.add():此处method.getName就是add
	 */
	@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+"方法");
	}
	//看房
	private void seeHouse(){
		System.out.println("带房客看房");
	}
	//收中介费
	private void fare(){
		System.out.println("收取中介费");
	}

}

Client:

import cn.sxt.service.UserService;
import cn.sxt.service.UserServiceImpl;

public class Client {
	public static void main(String[] args) {

		UserService userService=new UserServiceImpl();
		ProxyInvocationHandler pih=new ProxyInvocationHandler();
		pih.setTarget(userService);
		UserService proxy=(UserService)pih.getProxy();
		proxy.add();
	}
}

一个动态代理一般代理某一类业务，一个动态代理可以代理多各类