对Proxy.newProxyInstance的一些理解

****import java.lang.reflect.proxy：*动态代理
Proxy.newProxyInstance(ClassLoader loader, Class<?>[] interfaces,InvocationHandler h)
loader ：the class loader to define the proxy
定义真实对象的类加载器
classinterfaces ：the list of interfaces for the proxy class to implement
实现代理类的接口列表
h ： the invocation handler to dispatch method invocations to
将方法调用到处理程序
具有指定的代理类
调用
处理程序的代理实例，
该代理类
由指定的类加载器定义
并实现指定的接口

		//返回代理类的一个实例，返回后的代理类可以当作被代理类使用(可使用被代理类的在Subject接口中声明过的方法)。 
		return Proxy.newProxyInstance(/*  */
				// 参数1：真实对象的类加载器
				myBeanpostProcessor.class.getClassLoader(),
				//参数2：真实对象实现的所有的接口,接口是特殊的类，使用Class[]装载多个接口
				bean.getClass().getInterfaces(), 
				//参数3： 接口，传递一个匿名内部类对象
				new InvocationHandler() {
					 	//proxy 代理对象
                    	//method:代理的方法对象
                    	//args:方法调用时参数
						public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
						System.out.println("开启事务");
						Object obj=method.invoke(bean, args);//代理类，参数
					    System.out.println("关闭事务");
							return obj;
								}
					});/*  */
	}
}

分割线--------------------------------------------------------------------------------------------------------------------

前面是开发文档的意思，让人比较难理解。我用自己的话对AOP中的动态代理进行解释

我想对UserService类中的方法，每一个都添加开启事务和提交事务的方法。
但是又不改动UserService，所以采用了AOP思想
用Spring生成了一个UserService的代理类，可以调用UserService的方法，也可以把事务类的方法添加到代理类中。完成了我们想要的情况。
 经典应用：事务管理，性能监控，安全检查，缓存，日志。
 接口+实现类，Spring采用JDK的动态代理Proxy
 实现类：Spring采用cglib字节码增强

AOP的术语
1.Target Object(目标对象):需要被代理的类 例如：UserService
2.Joinpoint(连接点):那些可能被拦截的方法 例如：UserService中的所有方法
3.Pointcut(切入点):是指已经被增强的方法 例如：addUser()
4.Advice(通知/增强处理):增强代码 例如：befor(),after()
5.Weaving(织入)：将切面代码插入到目标对象上，从而生成代理对象的过程
6.Proxy(代理)：动态创建的代理类
7.Aspect(切面)：advice通知和Pointcut切入点组成的面
一条线是一个特殊的面
一个advice通知的点和Pointcut切入点组成的特殊的面

//切面类Aspect
public class MyAspect {
	
	public void befor() {
		System.out.println("开启事务");
	}
	public void after() {
		System.out.println("事务提交");
	}

//目标类Target
public interface UserService {
	public void addUser();
	public void deleteUser();

}

//实现类
public class UserServiceimpl implements UserService {
	public void addUser() {
		System.out.println("添加用户成功");
	}
	public void deleteUser() {
		System.out.println("删除用户成功");
		
	}
	

}

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

//工厂类
public class MyBeanFactory{
	
	public static UserService CreateUserService() {
//		目标类
//		addUser() <--开辟了一个实现类的堆给他
		
		UserService userService=new UserServiceimpl();

//		切面类Aspect
		MyAspect myAspect=new MyAspect();
//      代理类：将目标类（切入点）和切面类（通知）结合-->切面
//		Proxy.newProxyInstance
//		参数1：loader,类加载器,动态代理类，运行时创建，如何类都需要类加载器将其加载到内存
//		一般情况：当前类.class.getClassLoader();
//				目标类实例.getClass().getClassLoader();
//		参数2：Class[] interfaces 代理类需要实现的所有接口
//			方式1：目标类实例.getClass.getInterfaces();注意：只能获得自己的接口，不能获得父类元素接口
//			方式2：new class[]{UserService.class}
//		参数3：InvocationHandler() 处理类，接口，必须进行实现类，一般采用匿名内部
//		提供invoke方法，代理类的每一个方法执行时，都将调用一次invoke
//			参数31：Object proxy:代理对象
//			参数32：Method method:代理对象当前执行的方法的描述对象（反射）
//			参数33:Object[] args:方法实际参数
		
		
		
		UserService proxySvice=(UserService) Proxy.newProxyInstance(
				MyBeanFactory.class.getClassLoader(), 
				userService.getClass().getInterfaces(),
				new InvocationHandler() {

					@Override
					public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
						myAspect.befor();//事务开启
						Object obj=method.invoke(userService, args);
						myAspect.after();//事务提交
						return obj;
					}
				});
		return proxySvice;	
	}

}

最后就是测试类

import org.junit.Test;

//测试类
public class AopText {
	@Test
	public void demo() {
		UserService userService=MyBeanFactory.CreateUserService();
		userService.addUser();
		userService.deleteUser();
		
		
	}

}

输出结果

分割线------------------------------------------------------------------------------------------------
不懂的可以在评论问我。。。。。