黑马程序员_代理

最新推荐文章于 2024-09-05 23:10:07 发布

Crazy-J

最新推荐文章于 2024-09-05 23:10:07 发布

阅读量520

点赞数

文章标签： java

本文链接：https://blog.csdn.net/u010221057/article/details/22362799

版权

java 专栏收录该内容

20 篇文章 0 订阅

订阅专栏

------- android培训、java培训、期待与您交流！ ----------

一．概述

1.生活中的代理：

兰州人从兰州的代理商买联想电脑相比于跑到北京联想总部去买，代理商将厂商生产的电脑卖给消费者，消费者就可以省去不必要的麻烦和经济开支。

2.程序中的代理：

为已存在的多个具有相同接口的目标类的各个方法增加一些系统功能，例如，异常处理、日志、计算方法的运行时间、事务管理、等等。

3.实现：

编写一个与目标类具有相同接口的代理类，代理类的每个方法调用目标类的相同方法，并在调用方法时加上系统功能的代码。

4. 代理架构图：

5.优势：

如果采用工厂模式和配置文件的方式进行管理，则不需要修改客户端程序，在配置文件中配置是使用目标类、还是代理类，这样以后很容易切换，譬如，想要

日志功能时就配置代理类，否则配置目标类，这样，增加系统功能很容易，以后运行一段时间后，又想去掉系统功能也很容易。

二．AOP

1. AOP(Aspectoriented program),面向方面编程。

2.示意图：

系统中存在交叉业务，一个交叉业务就是要切入到系统中的一个方面

安全事务日志

StudentService ------|----------|------------|-------------

CourseService ------|----------|------------|-------------

MiscService ------|----------|------------|-------------

安全，事务，日志等功能贯穿好多个模块中，所以，它们就是交叉业务。

用具体的程序代码描述交叉业务：

method1 method2 method3

{ { {

------------------------------------------------------切面

.... .... ......

------------------------------------------------------切面

} } }

交叉业务的编程问题即为面向方面的编程（Aspect oriented program ,简称AOP），AOP的目标就是要使交叉业务模块化。可以采用将切面代码移动到原始方

法的周围，这与直接在方法中编写切面代码的运行效果是一样的，如下所示：

------------------------------------------------------切面

func1 func2 func3

{ { {

. ... .... ......

} } }

------------------------------------------------------切面

使用代理技术正好可以解决这种问题，代理是实现AOP功能的核心和关键技术。

三.动态代理技术

1.要为系统中的各种接口的类增加代理功能，那将需要太多的代理类，全部采用静态代理方式，将是一件非常麻烦的事情！

2.JVM可以在运行期动态生成出类的字节码，这种动态生成的类往往被用作代理类，即动态代理类。

3.JVM生成的动态类必须实现一个或多个接口，所以，JVM生成的动态类只能用作具有相同接口的目标类的代理。

4.CGLIB库可以动态生成一个类的子类，一个类的子类也可以用作该类的代理，所以，如果要为一个没有实现接口的类生成动态代理类，那么可以使用CGLIB

库。

5.代理类的各个方法中通常除了要调用目标的相应方法和对外返回目标返回的结果外，还可以在代理方法中的如下四个位置加上系统功能代码：

a.在调用目标方法之前

b.在调用目标方法之后

c.在调用目标方法前后

d.在处理目标方法异常的catch块中

创建实现了Collection接口的代理类及查看方法列表信息:

代码：

  package cn.itheima.day3;
import java.lang.reflect.Constructor;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.Collection;

public class ProxyTest {
	@SuppressWarnings("unchecked")
	public static void main(String[] args) throws Exception {
	   // 返回代理类的 java.lang.Class 对象，并向其提供类加载器和接口数组。
		Class clazzProxy1 = Proxy.getProxyClass(Collection.class
				.getClassLoader(), Collection.class);
		System.out.println(clazzProxy1.getName()); // $Proxy0

		System.out
				.println("----------begin constructors  list---------------------");
        //getConstructors():按照声明顺序返回一组 TypeVariable 对象，这些对象表示通过此 GenericDeclaration 对象所表示的一般

//声明来声明的类型变量。
		Constructor[] constructors = clazzProxy1.getConstructors();
		for (Constructor constructor : constructors) {
			String name = constructor.getName();
			StringBuilder sBuilder = new StringBuilder();
			sBuilder.append(name);
			sBuilder.append('(');
			Class[] clazzParams = constructor.getParameterTypes();
			for (Class clazzParam : clazzParams) {

				sBuilder.append(clazzParam.getName()).append(',');

			}
			if (clazzParams != null && clazzParams.length != 0)
				sBuilder.deleteCharAt(sBuilder.length() - 1);

			sBuilder.append(')');
			System.out.println(sBuilder.toString());
		}

		System.out.println("----------begin methods  list---------------------");
		Method[] methods = clazzProxy1.getMethods();
		for (Method method : methods) {
			String name = method.getName();
			StringBuilder sBuilder = new StringBuilder();
			sBuilder.append(name);
			sBuilder.append('(');
			Class[] clazzParams = method.getParameterTypes();
			for (Class clazzParam : clazzParams) {
				sBuilder.append(clazzParam.getName()).append(',');
			}
			if (clazzParams != null && clazzParams.length != 0)
				sBuilder.deleteCharAt(sBuilder.length() - 1);

			sBuilder.append(')');
			System.out.println(sBuilder.toString());
		}
        }
    }

6.创建动态类的实例对象：

用反射获得构造方法。

编写一个最简单的InvocationHandler类。

调用构造方法创建动态类的实例对象，并将编写的InvocationHandler类的实例对象传进去。

打印创建的对象和调用对象的没有返回值的方法和getClass方法，演示调用其他有返回值的方法报告了异常。

将创建动态类的实例对象的代理改成匿名内部类的形式编写。

用Proxy.newInstance方法直接一步就创建出代理对象。

代码：

package cn.itheima.day3;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.ArrayList;
import java.util.Collection;

public class ProxyTest2 {

	@SuppressWarnings("unchecked")
	public static void main(String[] args) throws Exception {
		Class clazzProxy1 = Proxy.getProxyClass(Collection.class
				.getClassLoader(), Collection.class);

		// 创建实例对象
		// 方式一：通过创建InvocationHandler子类
		Constructor constructor = clazzProxy1
				.getConstructor(InvocationHandler.class);
		class MyInvocationHandler1 implements InvocationHandler {

			public Object invoke(Object proxy, Method method, Object[] args)
					throws Throwable {
				return null;
			}
		}
		Collection proxy1 = (Collection) constructor
				.newInstance(new MyInvocationHandler1());
		System.out.println(proxy1); // null toString() （方法被省略）返回null
		proxy1.clear(); // 没有返回值 不报告异常
		// proxy1.size(); //有返回值 有异常

		// 方式二：利用匿名内部类来创建InvocationHandler子类对象
		Collection proxy2 = (Collection) constructor
				.newInstance(new InvocationHandler() {

					public Object invoke(Object proxy, Method method,
							Object[] args) throws Throwable {
						return null;
					}

				});

		// 方式三：用静态newProxyInstance方法来创建代理类实例对象
		// 目标对象
		final ArrayList target = new ArrayList();
		Collection proxy3 = (Collection) Proxy.newProxyInstance(
				Collection.class.getClassLoader(), target.getClass()
						.getInterfaces(), new InvocationHandler() {
					// 复写invoke()方法
					public Object invoke(Object proxy, Method method,
							Object[] args) throws Throwable {

						long beginTime = System.currentTimeMillis();
						Object retVal = method.invoke(target, args);
						long endTime = System.currentTimeMillis();
						// 方法的运行时间
						System.out.println(method.getName()
								+ "....running time:" + (endTime - beginTime));
						return retVal;
					}
				});
		// 调用一次add方法，就会找一次InvocationHandler这个参数的invoke方法
		proxy3.add("bxd");
		proxy3.add("lhm");
		proxy3.add("flx");
		System.out.println(proxy3.size());// 3
	}

}

7.让java虚拟机创建动态类及其实例对象，需要的信息：

三个方面：

生成的类中有哪些方法，通过让其实现哪些接口的方式进行告知。

产生的类字节码必须有个一个关联的类加载器对象。

生成的类中的方法的代码是怎样的，也得由我们提供。把我们的代码写在一个约定好了接口对象的方法中，把对象传给它，它调用我的方法，即相当于插入

了我的代码。提供执行代码的对象就是那个InvocationHandler对象，它是在创建动态类的实例对象的构造方法时传递进去的。在上面的InvocationHandler对象

的invoke方法中加一点代码，就可以看到这些代码被调用运行了。

四.分析动态生成的类的内部代码

1.动态生成的类实现了Collection接口（可以实现若干接口），生成的类有Collection接口中的所有方法和一个如下接受InvocationHandler参数的构造方法。

2.构造函数接收一个InvocationHandler对象，就是为了要记住该对象，以便在需要的时候调用。

3.生成的对象内部都调用了传递进来的handler对象的invoke()方法。

4.客户端程序调用objProxy.add(“abc”)方法时，涉及三要素：objProxy对象、add方法、“abc”参数。

代码体现：

  Class Proxy$ {
	    add(Object object) {
return handler.invoke(Object proxy, Method method, Object[] args);
	  }
}

5.说明：

Object proxy即为objProxy对象，Method method对应add方法，Object[] args就是”abc”参数。

6.分析：为什么动态类的实例对象的getClass()方法返回了正确结果呢？

调用调用代理对象的从Object类继承的hashCode, equals, 或toString这几个方法时，代理对象将调用请求转发给InvocationHandler对象，对于其他方法，则不

转发调用请求。

五.让动态生成的类成为目标类的代理

1.动态代理的工作原理：

Client(客户端)调用代理，代理的构造方法接收一个InvocationHandler，client调用代理的各个方法，代理的各个方法请求转发给刚才通过构造方法传入的handler

对象，又把各请求分发给目标的相应的方法。

2.将目标类传进去的方法：

直接在InvocationHandler实现类中创建目标类的实例对象，可以看运行效果和加入日志代码，但没有实际意义。

为InvocationHandler实现类注入目标类的实例对象，不能采用匿名内部类的形式了。

让匿名的InvocationHandler实现类访问外面方法中的目标类实例对象的final类型的引用变量

将创建代理的过程改为一种更优雅的方式，eclipse重构出一个getProxy方法绑定接收目标同时返回代理对象，让调用者更懒惰，更方便，调用者甚至不用接触

任何代理的API。

将系统功能代码模块化，即将切面代码也改为通过参数形式提供，把要执行的代码装到一个对象的某个方法里，然后把这个对象作为参数传递，接收者只要调

用这个对象的方法，即等于执行了外界提供的代码！

为getProxy方法增加一个Advice参数。

代码：

 package cn.itheima.day3;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.ArrayList;
import java.util.Collection;
public class ProxyTest {
	@SuppressWarnings("unchecked")
	public static void main(String[] args) throws Exception {
	   // 返回代理类的 java.lang.Class 对象，并向其提供类加载器和接口数组。
		Class clazzProxy1 = Proxy.getProxyClass(Collection.class
				.getClassLoader(), Collection.class);
		System.out.println(clazzProxy1.getName()); // $Proxy0
		//目标对象
		final ArrayList target = new ArrayList();
		Collection proxy3 = (Collection) getProxy(target, new MyAdvice());
		proxy3.add("bxd");
		proxy3.add("lhm");
		proxy3.add("flx");
		System.out.println(proxy3.size());
	}
    //重构的getProxy方法
	private static Object getProxy(final Object target, final Advice advice) {
		Object proxy3 = (Object) Proxy.newProxyInstance(Collection.class
				.getClassLoader(), /* new Class[]{Collection.class} */target
				.getClass().getInterfaces(), new InvocationHandler() {
             //复写invoke()方法
			public Object invoke(Object proxy, Method method, Object[] args)
					throws Throwable {
				advice.beforeMetod(method);
				Object retVal = method.invoke(target, args);
				advice.afterMetod(method);
				return retVal;
			}
		});
		return proxy3;
	}
}
//接口
 package cn.itheima.day3;
import java.lang.reflect.Method;

public interface Advice {
   void beforeMetod(Method method);
   void afterMetod(Method method);
}
//实现接口
 package cn.itheima.day3;
import java.lang.reflect.Method;
public class MyAdvice implements Advice {
  long beginTime=0;
	public void afterMetod(Method method) {		
		System.out.println("从黑马程序员训练营毕业，上班了");
		long endTime=System.currentTimeMillis();
		System.out.println(method.getName()+"....running time:"+(endTime-beginTime));
	}
	public void beforeMetod(Method method) {		
		System.out.println("到黑马程序员训练营学习");
		 beginTime=System.currentTimeMillis();
	}
}

六.实现AOP功能的封装与配置

1.工厂类BeanFactory负责创建目标类或代理类的实例对象，并通过配置文件实现切换其getBean方法根据参数字符串返回一个相应的实例对象，如果参数字符

串在配置文件中对应的类名不是ProxyFactoryBean，则直接返回该类的实例对象，否则，返回该类实例对象的getProxy方法返回的对象。

2.BeanFactory的构造方法接收代表配置文件的输入流对象，配置文件格式如下：

#xxx=java.util.ArrayList

xxx=cn.itcast.ProxyFactoryBean

xxx.target=java.util.ArrayList

xxx.advice=cn.itcast.MyAdvice

注意： #代表注释

3.ProxyFacotryBean充当封装生成动态代理的工厂，需要为工厂类提供配置参数信息：

目标

通知

配置文件放在和测试代码同一个包中。内容：

xxx=cn.itcast.day3.aopframework.ProxyFactoryBean

xxx.advice=cn.itcast.day3.MyAdvice

xxx.target=java.util.ArrayList

测试类代码：

package cn.itheima.day3.aopframework;
import java.io.InputStream;
public class AopFrameWorkTest {
    public static void main(String[] args)throws Exception {
    	//创建输入流对象，并与配置文件关联
    	InputStream ips=AopFrameWorkTest.class.getResourceAsStream("config.properties");
    	//获取bean对象
    	Object bean=new BeanFactory(ips).getBean("xxx");
    	System.out.println(bean.getClass().getName());//判断是代理还是目标
    	
	}
}

BeanFactory类代码：

package cn.itheima.day3.aopframework;
import java.io.InputStream;
import java.util.Properties;
import cn.itheima.day3.Advice;
public class BeanFactory {
	Properties props = new Properties();

	public BeanFactory(InputStream ips) {
		try {
			props.load(ips);
		} catch (Exception e) {
			// TODO: handle exception
			e.printStackTrace();
		}
	}

	public Object getBean(String name) {
		String className = props.getProperty(name);
		Object bean = null;
		try {
			Class clazz = Class.forName(className);
			bean = clazz.newInstance();
		} catch (Exception e) {
			e.printStackTrace();
		}

		// 类型判断
		if (bean instanceof ProxyFactoryBean) {
			Object proxy = null;
			try {

				ProxyFactoryBean proxyFactoryBean = (ProxyFactoryBean) bean;

				Advice advice = (Advice) Class.forName(
						props.getProperty(name + ".advice")).newInstance();
				Object target = Class.forName(
						props.getProperty(name + ".target")).newInstance();
				proxyFactoryBean.setAdvice(advice);
				proxyFactoryBean.setTarget(target);
				proxy = proxyFactoryBean.getProxy();
			} catch (Exception e) {
				// TODO: handle exception
			}
			return proxy;
		}
		return bean;
	}
}

ProxyFactoryBean类代码：

package cn.itheima.day3.aopframework;
import java.io.InputStream;
import java.util.Properties;
import cn.itheima.day3.Advice;
public class BeanFactory {
	Properties props = new Properties();

	public BeanFactory(InputStream ips) {
		try {
			props.load(ips);
		} catch (Exception e) {
			// TODO: handle exception
			e.printStackTrace();
		}
	}

	public Object getBean(String name) {
		String className = props.getProperty(name);
		Object bean = null;
		try {
			Class clazz = Class.forName(className);
			bean = clazz.newInstance();
		} catch (Exception e) {
			e.printStackTrace();
		}

		// 类型判断
		if (bean instanceof ProxyFactoryBean) {
			Object proxy = null;
			try {

				ProxyFactoryBean proxyFactoryBean = (ProxyFactoryBean) bean;

				Advice advice = (Advice) Class.forName(
						props.getProperty(name + ".advice")).newInstance();
				Object target = Class.forName(
						props.getProperty(name + ".target")).newInstance();
				proxyFactoryBean.setAdvice(advice);
				proxyFactoryBean.setTarget(target);
				proxy = proxyFactoryBean.getProxy();
			} catch (Exception e) {
				// TODO: handle exception
			}
			return proxy;
		}
		return bean;
	}
}
ProxyFactoryBean类代码：
    package cn.itheima.day3.aopframework;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.Collection;
import cn.itheima.day3.Advice;
public class ProxyFactoryBean {
	private Advice advice;
	private Object target;
	public Advice getAdvice() {
		return advice;
	}
	public void setAdvice(Advice advice) {
		this.advice = advice;
	}
	public Object getTarget() {
		return target;
	}
	public void setTarget(Object target) {
		this.target = target;
	}
	public Object getProxy() {
				Object proxy3 = (Object) Proxy.newProxyInstance(
				//定义代理类的类加载器
				Collection.class.getClassLoader(), 
				//代理类要实现的接口，这里要与target实现相同的接口    
				target.getClass().getInterfaces(),
				new InvocationHandler() {
					public Object invoke(Object proxy, Method method,
							Object[] args) throws Throwable {
						advice.beforeMetod(method);
						Object retVal = method.invoke(target, args);
						advice.afterMetod(method);
						return retVal;
					}
				});
		return proxy3;
	}
}

------- android培训、java培训、期待与您交流！ ----------

Crazy-J

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
黑马程序员_代理

------- android培训、java培训、期待与您交流！ ---------- 一．概述 1.生活中的代理：兰州人从兰州的代理商买联想电脑相比于跑到北京联想总部去买，代理商将厂商生产的电脑卖给消费者，消费者就可以省去不必要的麻烦和经济开支。 2.程序中的代理：为已存在的多个具有相同接口的目标类的各个方法增加一些系统功能，例如，异常处理
复制链接

扫一扫

专栏目录